Add files using upload-large-folder tool

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy-1.14.0.dist-info/INSTALLER

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

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy-1.14.0.dist-info/METADATA

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

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy-1.14.0.dist-info/WHEEL

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

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy-1.14.0.dist-info/entry_points.txt

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

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy-1.14.0.dist-info/licenses/AUTHORS

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

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy-1.14.0.dist-info/licenses/LICENSE

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

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy-1.14.0.dist-info/top_level.txt

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

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_piab.py

@@ -0,0 +1,29 @@
+"""Tests for piab.py"""
+
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.sets.sets import Interval
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.physics.quantum import L2, qapply, hbar, represent
+from sympy.physics.quantum.piab import PIABHamiltonian, PIABKet, PIABBra, m, L
+
+i, j, n, x = symbols('i j n x')
+
+
+def test_H():
+    assert PIABHamiltonian('H').hilbert_space == \
+        L2(Interval(S.NegativeInfinity, S.Infinity))
+    assert qapply(PIABHamiltonian('H')*PIABKet(n)) == \
+        (n**2*pi**2*hbar**2)/(2*m*L**2)*PIABKet(n)
+
+
+def test_states():
+    assert PIABKet(n).dual_class() == PIABBra
+    assert PIABKet(n).hilbert_space == \
+        L2(Interval(S.NegativeInfinity, S.Infinity))
+    assert represent(PIABKet(n)) == sqrt(2/L)*sin(n*pi*x/L)
+    assert (PIABBra(i)*PIABKet(j)).doit() == KroneckerDelta(i, j)
+    assert PIABBra(n).dual_class() == PIABKet

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_printing.py

@@ -0,0 +1,900 @@
+# -*- encoding: utf-8 -*-
+"""
+TODO:
+* Address Issue 2251, printing of spin states
+"""
+from __future__ import annotations
+from typing import Any
+
+from sympy.physics.quantum.anticommutator import AntiCommutator
+from sympy.physics.quantum.cg import CG, Wigner3j, Wigner6j, Wigner9j
+from sympy.physics.quantum.commutator import Commutator
+from sympy.physics.quantum.constants import hbar
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.gate import CGate, CNotGate, IdentityGate, UGate, XGate
+from sympy.physics.quantum.hilbert import ComplexSpace, FockSpace, HilbertSpace, L2
+from sympy.physics.quantum.innerproduct import InnerProduct
+from sympy.physics.quantum.operator import Operator, OuterProduct, DifferentialOperator
+from sympy.physics.quantum.qexpr import QExpr
+from sympy.physics.quantum.qubit import Qubit, IntQubit
+from sympy.physics.quantum.spin import Jz, J2, JzBra, JzBraCoupled, JzKet, JzKetCoupled, Rotation, WignerD
+from sympy.physics.quantum.state import Bra, Ket, TimeDepBra, TimeDepKet
+from sympy.physics.quantum.tensorproduct import TensorProduct
+from sympy.physics.quantum.sho1d import RaisingOp
+
+from sympy.core.function import (Derivative, Function)
+from sympy.core.numbers import oo
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.matrices.dense import Matrix
+from sympy.sets.sets import Interval
+from sympy.testing.pytest import XFAIL
+
+# Imports used in srepr strings
+from sympy.physics.quantum.spin import JzOp
+
+from sympy.printing import srepr
+from sympy.printing.pretty import pretty as xpretty
+from sympy.printing.latex import latex
+
+MutableDenseMatrix = Matrix
+
+
+ENV: dict[str, Any] = {}
+exec('from sympy import *', ENV)
+exec('from sympy.physics.quantum import *', ENV)
+exec('from sympy.physics.quantum.cg import *', ENV)
+exec('from sympy.physics.quantum.spin import *', ENV)
+exec('from sympy.physics.quantum.hilbert import *', ENV)
+exec('from sympy.physics.quantum.qubit import *', ENV)
+exec('from sympy.physics.quantum.qexpr import *', ENV)
+exec('from sympy.physics.quantum.gate import *', ENV)
+exec('from sympy.physics.quantum.constants import *', ENV)
+
+
+def sT(expr, string):
+    """
+    sT := sreprTest
+    from sympy/printing/tests/test_repr.py
+    """
+    assert srepr(expr) == string
+    assert eval(string, ENV) == expr
+
+
+def pretty(expr):
+    """ASCII pretty-printing"""
+    return xpretty(expr, use_unicode=False, wrap_line=False)
+
+
+def upretty(expr):
+    """Unicode pretty-printing"""
+    return xpretty(expr, use_unicode=True, wrap_line=False)
+
+
+def test_anticommutator():
+    A = Operator('A')
+    B = Operator('B')
+    ac = AntiCommutator(A, B)
+    ac_tall = AntiCommutator(A**2, B)
+    assert str(ac) == '{A,B}'
+    assert pretty(ac) == '{A,B}'
+    assert upretty(ac) == '{A,B}'
+    assert latex(ac) == r'\left\{A,B\right\}'
+    sT(ac, "AntiCommutator(Operator(Symbol('A')),Operator(Symbol('B')))")
+    assert str(ac_tall) == '{A**2,B}'
+    ascii_str = \
+"""\
+/ 2  \\\n\
+<A ,B>\n\
+\\    /\
+"""
+    ucode_str = \
+"""\
+⎧ 2  ⎫\n\
+⎨A ,B⎬\n\
+⎩    ⎭\
+"""
+    assert pretty(ac_tall) == ascii_str
+    assert upretty(ac_tall) == ucode_str
+    assert latex(ac_tall) == r'\left\{A^{2},B\right\}'
+    sT(ac_tall, "AntiCommutator(Pow(Operator(Symbol('A')), Integer(2)),Operator(Symbol('B')))")
+
+
+def test_cg():
+    cg = CG(1, 2, 3, 4, 5, 6)
+    wigner3j = Wigner3j(1, 2, 3, 4, 5, 6)
+    wigner6j = Wigner6j(1, 2, 3, 4, 5, 6)
+    wigner9j = Wigner9j(1, 2, 3, 4, 5, 6, 7, 8, 9)
+    assert str(cg) == 'CG(1, 2, 3, 4, 5, 6)'
+    ascii_str = \
+"""\
+ 5,6    \n\
+C       \n\
+ 1,2,3,4\
+"""
+    ucode_str = \
+"""\
+ 5,6    \n\
+C       \n\
+ 1,2,3,4\
+"""
+    assert pretty(cg) == ascii_str
+    assert upretty(cg) == ucode_str
+    assert latex(cg) == 'C^{5,6}_{1,2,3,4}'
+    assert latex(cg ** 2) == R'\left(C^{5,6}_{1,2,3,4}\right)^{2}'
+    sT(cg, "CG(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6))")
+    assert str(wigner3j) == 'Wigner3j(1, 2, 3, 4, 5, 6)'
+    ascii_str = \
+"""\
+/1  3  5\\\n\
+|       |\n\
+\\2  4  6/\
+"""
+    ucode_str = \
+"""\
+⎛1  3  5⎞\n\
+⎜       ⎟\n\
+⎝2  4  6⎠\
+"""
+    assert pretty(wigner3j) == ascii_str
+    assert upretty(wigner3j) == ucode_str
+    assert latex(wigner3j) == \
+        r'\left(\begin{array}{ccc} 1 & 3 & 5 \\ 2 & 4 & 6 \end{array}\right)'
+    sT(wigner3j, "Wigner3j(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6))")
+    assert str(wigner6j) == 'Wigner6j(1, 2, 3, 4, 5, 6)'
+    ascii_str = \
+"""\
+/1  2  3\\\n\
+<       >\n\
+\\4  5  6/\
+"""
+    ucode_str = \
+"""\
+⎧1  2  3⎫\n\
+⎨       ⎬\n\
+⎩4  5  6⎭\
+"""
+    assert pretty(wigner6j) == ascii_str
+    assert upretty(wigner6j) == ucode_str
+    assert latex(wigner6j) == \
+        r'\left\{\begin{array}{ccc} 1 & 2 & 3 \\ 4 & 5 & 6 \end{array}\right\}'
+    sT(wigner6j, "Wigner6j(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6))")
+    assert str(wigner9j) == 'Wigner9j(1, 2, 3, 4, 5, 6, 7, 8, 9)'
+    ascii_str = \
+"""\
+/1  2  3\\\n\
+|       |\n\
+<4  5  6>\n\
+|       |\n\
+\\7  8  9/\
+"""
+    ucode_str = \
+"""\
+⎧1  2  3⎫\n\
+⎪       ⎪\n\
+⎨4  5  6⎬\n\
+⎪       ⎪\n\
+⎩7  8  9⎭\
+"""
+    assert pretty(wigner9j) == ascii_str
+    assert upretty(wigner9j) == ucode_str
+    assert latex(wigner9j) == \
+        r'\left\{\begin{array}{ccc} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{array}\right\}'
+    sT(wigner9j, "Wigner9j(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6), Integer(7), Integer(8), Integer(9))")
+
+
+def test_commutator():
+    A = Operator('A')
+    B = Operator('B')
+    c = Commutator(A, B)
+    c_tall = Commutator(A**2, B)
+    assert str(c) == '[A,B]'
+    assert pretty(c) == '[A,B]'
+    assert upretty(c) == '[A,B]'
+    assert latex(c) == r'\left[A,B\right]'
+    sT(c, "Commutator(Operator(Symbol('A')),Operator(Symbol('B')))")
+    assert str(c_tall) == '[A**2,B]'
+    ascii_str = \
+"""\
+[ 2  ]\n\
+[A ,B]\
+"""
+    ucode_str = \
+"""\
+⎡ 2  ⎤\n\
+⎣A ,B⎦\
+"""
+    assert pretty(c_tall) == ascii_str
+    assert upretty(c_tall) == ucode_str
+    assert latex(c_tall) == r'\left[A^{2},B\right]'
+    sT(c_tall, "Commutator(Pow(Operator(Symbol('A')), Integer(2)),Operator(Symbol('B')))")
+
+
+def test_constants():
+    assert str(hbar) == 'hbar'
+    assert pretty(hbar) == 'hbar'
+    assert upretty(hbar) == 'ℏ'
+    assert latex(hbar) == r'\hbar'
+    sT(hbar, "HBar()")
+
+
+def test_dagger():
+    x = symbols('x', commutative=False)
+    expr = Dagger(x)
+    assert str(expr) == 'Dagger(x)'
+    ascii_str = \
+"""\
+ +\n\
+x \
+"""
+    ucode_str = \
+"""\
+ †\n\
+x \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    assert latex(expr) == r'x^{\dagger}'
+    sT(expr, "Dagger(Symbol('x', commutative=False))")
+
+
+@XFAIL
+def test_gate_failing():
+    a, b, c, d = symbols('a,b,c,d')
+    uMat = Matrix([[a, b], [c, d]])
+    g = UGate((0,), uMat)
+    assert str(g) == 'U(0)'
+
+
+def test_gate():
+    a, b, c, d = symbols('a,b,c,d')
+    uMat = Matrix([[a, b], [c, d]])
+    q = Qubit(1, 0, 1, 0, 1)
+    g1 = IdentityGate(2)
+    g2 = CGate((3, 0), XGate(1))
+    g3 = CNotGate(1, 0)
+    g4 = UGate((0,), uMat)
+    assert str(g1) == '1(2)'
+    assert pretty(g1) == '1 \n 2'
+    assert upretty(g1) == '1 \n 2'
+    assert latex(g1) == r'1_{2}'
+    sT(g1, "IdentityGate(Integer(2))")
+    assert str(g1*q) == '1(2)*|10101>'
+    ascii_str = \
+"""\
+1 *|10101>\n\
+ 2        \
+"""
+    ucode_str = \
+"""\
+1 ⋅❘10101⟩\n\
+ 2        \
+"""
+    assert pretty(g1*q) == ascii_str
+    assert upretty(g1*q) == ucode_str
+    assert latex(g1*q) == r'1_{2} {\left|10101\right\rangle }'
+    sT(g1*q, "Mul(IdentityGate(Integer(2)), Qubit(Integer(1),Integer(0),Integer(1),Integer(0),Integer(1)))")
+    assert str(g2) == 'C((3,0),X(1))'
+    ascii_str = \
+"""\
+C   /X \\\n\
+ 3,0\\ 1/\
+"""
+    ucode_str = \
+"""\
+C   ⎛X ⎞\n\
+ 3,0⎝ 1⎠\
+"""
+    assert pretty(g2) == ascii_str
+    assert upretty(g2) == ucode_str
+    assert latex(g2) == r'C_{3,0}{\left(X_{1}\right)}'
+    sT(g2, "CGate(Tuple(Integer(3), Integer(0)),XGate(Integer(1)))")
+    assert str(g3) == 'CNOT(1,0)'
+    ascii_str = \
+"""\
+CNOT   \n\
+    1,0\
+"""
+    ucode_str = \
+"""\
+CNOT   \n\
+    1,0\
+"""
+    assert pretty(g3) == ascii_str
+    assert upretty(g3) == ucode_str
+    assert latex(g3) == r'\text{CNOT}_{1,0}'
+    sT(g3, "CNotGate(Integer(1),Integer(0))")
+    ascii_str = \
+"""\
+U \n\
+ 0\
+"""
+    ucode_str = \
+"""\
+U \n\
+ 0\
+"""
+    assert str(g4) == \
+"""\
+U((0,),Matrix([\n\
+[a, b],\n\
+[c, d]]))\
+"""
+    assert pretty(g4) == ascii_str
+    assert upretty(g4) == ucode_str
+    assert latex(g4) == r'U_{0}'
+    sT(g4, "UGate(Tuple(Integer(0)),ImmutableDenseMatrix([[Symbol('a'), Symbol('b')], [Symbol('c'), Symbol('d')]]))")
+
+
+def test_hilbert():
+    h1 = HilbertSpace()
+    h2 = ComplexSpace(2)
+    h3 = FockSpace()
+    h4 = L2(Interval(0, oo))
+    assert str(h1) == 'H'
+    assert pretty(h1) == 'H'
+    assert upretty(h1) == 'H'
+    assert latex(h1) == r'\mathcal{H}'
+    sT(h1, "HilbertSpace()")
+    assert str(h2) == 'C(2)'
+    ascii_str = \
+"""\
+ 2\n\
+C \
+"""
+    ucode_str = \
+"""\
+ 2\n\
+C \
+"""
+    assert pretty(h2) == ascii_str
+    assert upretty(h2) == ucode_str
+    assert latex(h2) == r'\mathcal{C}^{2}'
+    sT(h2, "ComplexSpace(Integer(2))")
+    assert str(h3) == 'F'
+    assert pretty(h3) == 'F'
+    assert upretty(h3) == 'F'
+    assert latex(h3) == r'\mathcal{F}'
+    sT(h3, "FockSpace()")
+    assert str(h4) == 'L2(Interval(0, oo))'
+    ascii_str = \
+"""\
+ 2\n\
+L \
+"""
+    ucode_str = \
+"""\
+ 2\n\
+L \
+"""
+    assert pretty(h4) == ascii_str
+    assert upretty(h4) == ucode_str
+    assert latex(h4) == r'{\mathcal{L}^2}\left( \left[0, \infty\right) \right)'
+    sT(h4, "L2(Interval(Integer(0), oo, false, true))")
+    assert str(h1 + h2) == 'H+C(2)'
+    ascii_str = \
+"""\
+     2\n\
+H + C \
+"""
+    ucode_str = \
+"""\
+     2\n\
+H ⊕ C \
+"""
+    assert pretty(h1 + h2) == ascii_str
+    assert upretty(h1 + h2) == ucode_str
+    assert latex(h1 + h2)
+    sT(h1 + h2, "DirectSumHilbertSpace(HilbertSpace(),ComplexSpace(Integer(2)))")
+    assert str(h1*h2) == "H*C(2)"
+    ascii_str = \
+"""\
+     2\n\
+H x C \
+"""
+    ucode_str = \
+"""\
+     2\n\
+H ⨂ C \
+"""
+    assert pretty(h1*h2) == ascii_str
+    assert upretty(h1*h2) == ucode_str
+    assert latex(h1*h2)
+    sT(h1*h2,
+       "TensorProductHilbertSpace(HilbertSpace(),ComplexSpace(Integer(2)))")
+    assert str(h1**2) == 'H**2'
+    ascii_str = \
+"""\
+ x2\n\
+H  \
+"""
+    ucode_str = \
+"""\
+ ⨂2\n\
+H  \
+"""
+    assert pretty(h1**2) == ascii_str
+    assert upretty(h1**2) == ucode_str
+    assert latex(h1**2) == r'{\mathcal{H}}^{\otimes 2}'
+    sT(h1**2, "TensorPowerHilbertSpace(HilbertSpace(),Integer(2))")
+
+
+def test_innerproduct():
+    x = symbols('x')
+    ip1 = InnerProduct(Bra(), Ket())
+    ip2 = InnerProduct(TimeDepBra(), TimeDepKet())
+    ip3 = InnerProduct(JzBra(1, 1), JzKet(1, 1))
+    ip4 = InnerProduct(JzBraCoupled(1, 1, (1, 1)), JzKetCoupled(1, 1, (1, 1)))
+    ip_tall1 = InnerProduct(Bra(x/2), Ket(x/2))
+    ip_tall2 = InnerProduct(Bra(x), Ket(x/2))
+    ip_tall3 = InnerProduct(Bra(x/2), Ket(x))
+    assert str(ip1) == '<psi|psi>'
+    assert pretty(ip1) == '<psi|psi>'
+    assert upretty(ip1) == '⟨ψ❘ψ⟩'
+    assert latex(
+        ip1) == r'\left\langle \psi \right. {\left|\psi\right\rangle }'
+    sT(ip1, "InnerProduct(Bra(Symbol('psi')),Ket(Symbol('psi')))")
+    assert str(ip2) == '<psi;t|psi;t>'
+    assert pretty(ip2) == '<psi;t|psi;t>'
+    assert upretty(ip2) == '⟨ψ;t❘ψ;t⟩'
+    assert latex(ip2) == \
+        r'\left\langle \psi;t \right. {\left|\psi;t\right\rangle }'
+    sT(ip2, "InnerProduct(TimeDepBra(Symbol('psi'),Symbol('t')),TimeDepKet(Symbol('psi'),Symbol('t')))")
+    assert str(ip3) == "<1,1|1,1>"
+    assert pretty(ip3) == '<1,1|1,1>'
+    assert upretty(ip3) == '⟨1,1❘1,1⟩'
+    assert latex(ip3) == r'\left\langle 1,1 \right. {\left|1,1\right\rangle }'
+    sT(ip3, "InnerProduct(JzBra(Integer(1),Integer(1)),JzKet(Integer(1),Integer(1)))")
+    assert str(ip4) == "<1,1,j1=1,j2=1|1,1,j1=1,j2=1>"
+    assert pretty(ip4) == '<1,1,j1=1,j2=1|1,1,j1=1,j2=1>'
+    assert upretty(ip4) == '⟨1,1,j₁=1,j₂=1❘1,1,j₁=1,j₂=1⟩'
+    assert latex(ip4) == \
+        r'\left\langle 1,1,j_{1}=1,j_{2}=1 \right. {\left|1,1,j_{1}=1,j_{2}=1\right\rangle }'
+    sT(ip4, "InnerProduct(JzBraCoupled(Integer(1),Integer(1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1)))),JzKetCoupled(Integer(1),Integer(1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1)))))")
+    assert str(ip_tall1) == '<x/2|x/2>'
+    ascii_str = \
+"""\
+ / | \\ \n\
+/ x|x \\\n\
+\\ -|- /\n\
+ \\2|2/ \
+"""
+    ucode_str = \
+"""\
+ ╱ │ ╲ \n\
+╱ x│x ╲\n\
+╲ ─│─ ╱\n\
+ ╲2│2╱ \
+"""
+    assert pretty(ip_tall1) == ascii_str
+    assert upretty(ip_tall1) == ucode_str
+    assert latex(ip_tall1) == \
+        r'\left\langle \frac{x}{2} \right. {\left|\frac{x}{2}\right\rangle }'
+    sT(ip_tall1, "InnerProduct(Bra(Mul(Rational(1, 2), Symbol('x'))),Ket(Mul(Rational(1, 2), Symbol('x'))))")
+    assert str(ip_tall2) == '<x|x/2>'
+    ascii_str = \
+"""\
+ / | \\ \n\
+/  |x \\\n\
+\\ x|- /\n\
+ \\ |2/ \
+"""
+    ucode_str = \
+"""\
+ ╱ │ ╲ \n\
+╱  │x ╲\n\
+╲ x│─ ╱\n\
+ ╲ │2╱ \
+"""
+    assert pretty(ip_tall2) == ascii_str
+    assert upretty(ip_tall2) == ucode_str
+    assert latex(ip_tall2) == \
+        r'\left\langle x \right. {\left|\frac{x}{2}\right\rangle }'
+    sT(ip_tall2,
+       "InnerProduct(Bra(Symbol('x')),Ket(Mul(Rational(1, 2), Symbol('x'))))")
+    assert str(ip_tall3) == '<x/2|x>'
+    ascii_str = \
+"""\
+ / | \\ \n\
+/ x|  \\\n\
+\\ -|x /\n\
+ \\2| / \
+"""
+    ucode_str = \
+"""\
+ ╱ │ ╲ \n\
+╱ x│  ╲\n\
+╲ ─│x ╱\n\
+ ╲2│ ╱ \
+"""
+    assert pretty(ip_tall3) == ascii_str
+    assert upretty(ip_tall3) == ucode_str
+    assert latex(ip_tall3) == \
+        r'\left\langle \frac{x}{2} \right. {\left|x\right\rangle }'
+    sT(ip_tall3,
+       "InnerProduct(Bra(Mul(Rational(1, 2), Symbol('x'))),Ket(Symbol('x')))")
+
+
+def test_operator():
+    a = Operator('A')
+    b = Operator('B', Symbol('t'), S.Half)
+    inv = a.inv()
+    f = Function('f')
+    x = symbols('x')
+    d = DifferentialOperator(Derivative(f(x), x), f(x))
+    op = OuterProduct(Ket(), Bra())
+    assert str(a) == 'A'
+    assert pretty(a) == 'A'
+    assert upretty(a) == 'A'
+    assert latex(a) == 'A'
+    sT(a, "Operator(Symbol('A'))")
+    assert str(inv) == 'A**(-1)'
+    ascii_str = \
+"""\
+ -1\n\
+A  \
+"""
+    ucode_str = \
+"""\
+ -1\n\
+A  \
+"""
+    assert pretty(inv) == ascii_str
+    assert upretty(inv) == ucode_str
+    assert latex(inv) == r'A^{-1}'
+    sT(inv, "Pow(Operator(Symbol('A')), Integer(-1))")
+    assert str(d) == 'DifferentialOperator(Derivative(f(x), x),f(x))'
+    ascii_str = \
+"""\
+                    /d            \\\n\
+DifferentialOperator|--(f(x)),f(x)|\n\
+                    \\dx           /\
+"""
+    ucode_str = \
+"""\
+                    ⎛d            ⎞\n\
+DifferentialOperator⎜──(f(x)),f(x)⎟\n\
+                    ⎝dx           ⎠\
+"""
+    assert pretty(d) == ascii_str
+    assert upretty(d) == ucode_str
+    assert latex(d) == \
+        r'DifferentialOperator\left(\frac{d}{d x} f{\left(x \right)},f{\left(x \right)}\right)'
+    sT(d, "DifferentialOperator(Derivative(Function('f')(Symbol('x')), Tuple(Symbol('x'), Integer(1))),Function('f')(Symbol('x')))")
+    assert str(b) == 'Operator(B,t,1/2)'
+    assert pretty(b) == 'Operator(B,t,1/2)'
+    assert upretty(b) == 'Operator(B,t,1/2)'
+    assert latex(b) == r'Operator\left(B,t,\frac{1}{2}\right)'
+    sT(b, "Operator(Symbol('B'),Symbol('t'),Rational(1, 2))")
+    assert str(op) == '|psi><psi|'
+    assert pretty(op) == '|psi><psi|'
+    assert upretty(op) == '❘ψ⟩⟨ψ❘'
+    assert latex(op) == r'{\left|\psi\right\rangle }{\left\langle \psi\right|}'
+    sT(op, "OuterProduct(Ket(Symbol('psi')),Bra(Symbol('psi')))")
+
+
+def test_qexpr():
+    q = QExpr('q')
+    assert str(q) == 'q'
+    assert pretty(q) == 'q'
+    assert upretty(q) == 'q'
+    assert latex(q) == r'q'
+    sT(q, "QExpr(Symbol('q'))")
+
+
+def test_qubit():
+    q1 = Qubit('0101')
+    q2 = IntQubit(8)
+    assert str(q1) == '|0101>'
+    assert pretty(q1) == '|0101>'
+    assert upretty(q1) == '❘0101⟩'
+    assert latex(q1) == r'{\left|0101\right\rangle }'
+    sT(q1, "Qubit(Integer(0),Integer(1),Integer(0),Integer(1))")
+    assert str(q2) == '|8>'
+    assert pretty(q2) == '|8>'
+    assert upretty(q2) == '❘8⟩'
+    assert latex(q2) == r'{\left|8\right\rangle }'
+    sT(q2, "IntQubit(8)")
+
+
+def test_spin():
+    lz = JzOp('L')
+    ket = JzKet(1, 0)
+    bra = JzBra(1, 0)
+    cket = JzKetCoupled(1, 0, (1, 2))
+    cbra = JzBraCoupled(1, 0, (1, 2))
+    cket_big = JzKetCoupled(1, 0, (1, 2, 3))
+    cbra_big = JzBraCoupled(1, 0, (1, 2, 3))
+    rot = Rotation(1, 2, 3)
+    bigd = WignerD(1, 2, 3, 4, 5, 6)
+    smalld = WignerD(1, 2, 3, 0, 4, 0)
+    assert str(lz) == 'Lz'
+    ascii_str = \
+"""\
+L \n\
+ z\
+"""
+    ucode_str = \
+"""\
+L \n\
+ z\
+"""
+    assert pretty(lz) == ascii_str
+    assert upretty(lz) == ucode_str
+    assert latex(lz) == 'L_z'
+    sT(lz, "JzOp(Symbol('L'))")
+    assert str(J2) == 'J2'
+    ascii_str = \
+"""\
+ 2\n\
+J \
+"""
+    ucode_str = \
+"""\
+ 2\n\
+J \
+"""
+    assert pretty(J2) == ascii_str
+    assert upretty(J2) == ucode_str
+    assert latex(J2) == r'J^2'
+    sT(J2, "J2Op(Symbol('J'))")
+    assert str(Jz) == 'Jz'
+    ascii_str = \
+"""\
+J \n\
+ z\
+"""
+    ucode_str = \
+"""\
+J \n\
+ z\
+"""
+    assert pretty(Jz) == ascii_str
+    assert upretty(Jz) == ucode_str
+    assert latex(Jz) == 'J_z'
+    sT(Jz, "JzOp(Symbol('J'))")
+    assert str(ket) == '|1,0>'
+    assert pretty(ket) == '|1,0>'
+    assert upretty(ket) == '❘1,0⟩'
+    assert latex(ket) == r'{\left|1,0\right\rangle }'
+    sT(ket, "JzKet(Integer(1),Integer(0))")
+    assert str(bra) == '<1,0|'
+    assert pretty(bra) == '<1,0|'
+    assert upretty(bra) == '⟨1,0❘'
+    assert latex(bra) == r'{\left\langle 1,0\right|}'
+    sT(bra, "JzBra(Integer(1),Integer(0))")
+    assert str(cket) == '|1,0,j1=1,j2=2>'
+    assert pretty(cket) == '|1,0,j1=1,j2=2>'
+    assert upretty(cket) == '❘1,0,j₁=1,j₂=2⟩'
+    assert latex(cket) == r'{\left|1,0,j_{1}=1,j_{2}=2\right\rangle }'
+    sT(cket, "JzKetCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(2)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))")
+    assert str(cbra) == '<1,0,j1=1,j2=2|'
+    assert pretty(cbra) == '<1,0,j1=1,j2=2|'
+    assert upretty(cbra) == '⟨1,0,j₁=1,j₂=2❘'
+    assert latex(cbra) == r'{\left\langle 1,0,j_{1}=1,j_{2}=2\right|}'
+    sT(cbra, "JzBraCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(2)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))")
+    assert str(cket_big) == '|1,0,j1=1,j2=2,j3=3,j(1,2)=3>'
+    # TODO: Fix non-unicode pretty printing
+    # i.e. j1,2 -> j(1,2)
+    assert pretty(cket_big) == '|1,0,j1=1,j2=2,j3=3,j1,2=3>'
+    assert upretty(cket_big) == '❘1,0,j₁=1,j₂=2,j₃=3,j₁,₂=3⟩'
+    assert latex(cket_big) == \
+        r'{\left|1,0,j_{1}=1,j_{2}=2,j_{3}=3,j_{1,2}=3\right\rangle }'
+    sT(cket_big, "JzKetCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(2), Integer(3)),Tuple(Tuple(Integer(1), Integer(2), Integer(3)), Tuple(Integer(1), Integer(3), Integer(1))))")
+    assert str(cbra_big) == '<1,0,j1=1,j2=2,j3=3,j(1,2)=3|'
+    assert pretty(cbra_big) == '<1,0,j1=1,j2=2,j3=3,j1,2=3|'
+    assert upretty(cbra_big) == '⟨1,0,j₁=1,j₂=2,j₃=3,j₁,₂=3❘'
+    assert latex(cbra_big) == \
+        r'{\left\langle 1,0,j_{1}=1,j_{2}=2,j_{3}=3,j_{1,2}=3\right|}'
+    sT(cbra_big, "JzBraCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(2), Integer(3)),Tuple(Tuple(Integer(1), Integer(2), Integer(3)), Tuple(Integer(1), Integer(3), Integer(1))))")
+    assert str(rot) == 'R(1,2,3)'
+    assert pretty(rot) == 'R (1,2,3)'
+    assert upretty(rot) == 'ℛ (1,2,3)'
+    assert latex(rot) == r'\mathcal{R}\left(1,2,3\right)'
+    sT(rot, "Rotation(Integer(1),Integer(2),Integer(3))")
+    assert str(bigd) == 'WignerD(1, 2, 3, 4, 5, 6)'
+    ascii_str = \
+"""\
+ 1         \n\
+D   (4,5,6)\n\
+ 2,3       \
+"""
+    ucode_str = \
+"""\
+ 1         \n\
+D   (4,5,6)\n\
+ 2,3       \
+"""
+    assert pretty(bigd) == ascii_str
+    assert upretty(bigd) == ucode_str
+    assert latex(bigd) == r'D^{1}_{2,3}\left(4,5,6\right)'
+    sT(bigd, "WignerD(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6))")
+    assert str(smalld) == 'WignerD(1, 2, 3, 0, 4, 0)'
+    ascii_str = \
+"""\
+ 1     \n\
+d   (4)\n\
+ 2,3   \
+"""
+    ucode_str = \
+"""\
+ 1     \n\
+d   (4)\n\
+ 2,3   \
+"""
+    assert pretty(smalld) == ascii_str
+    assert upretty(smalld) == ucode_str
+    assert latex(smalld) == r'd^{1}_{2,3}\left(4\right)'
+    sT(smalld, "WignerD(Integer(1), Integer(2), Integer(3), Integer(0), Integer(4), Integer(0))")
+
+
+def test_state():
+    x = symbols('x')
+    bra = Bra()
+    ket = Ket()
+    bra_tall = Bra(x/2)
+    ket_tall = Ket(x/2)
+    tbra = TimeDepBra()
+    tket = TimeDepKet()
+    assert str(bra) == '<psi|'
+    assert pretty(bra) == '<psi|'
+    assert upretty(bra) == '⟨ψ❘'
+    assert latex(bra) == r'{\left\langle \psi\right|}'
+    sT(bra, "Bra(Symbol('psi'))")
+    assert str(ket) == '|psi>'
+    assert pretty(ket) == '|psi>'
+    assert upretty(ket) == '❘ψ⟩'
+    assert latex(ket) == r'{\left|\psi\right\rangle }'
+    sT(ket, "Ket(Symbol('psi'))")
+    assert str(bra_tall) == '<x/2|'
+    ascii_str = \
+"""\
+ / |\n\
+/ x|\n\
+\\ -|\n\
+ \\2|\
+"""
+    ucode_str = \
+"""\
+ ╱ │\n\
+╱ x│\n\
+╲ ─│\n\
+ ╲2│\
+"""
+    assert pretty(bra_tall) == ascii_str
+    assert upretty(bra_tall) == ucode_str
+    assert latex(bra_tall) == r'{\left\langle \frac{x}{2}\right|}'
+    sT(bra_tall, "Bra(Mul(Rational(1, 2), Symbol('x')))")
+    assert str(ket_tall) == '|x/2>'
+    ascii_str = \
+"""\
+| \\ \n\
+|x \\\n\
+|- /\n\
+|2/ \
+"""
+    ucode_str = \
+"""\
+│ ╲ \n\
+│x ╲\n\
+│─ ╱\n\
+│2╱ \
+"""
+    assert pretty(ket_tall) == ascii_str
+    assert upretty(ket_tall) == ucode_str
+    assert latex(ket_tall) == r'{\left|\frac{x}{2}\right\rangle }'
+    sT(ket_tall, "Ket(Mul(Rational(1, 2), Symbol('x')))")
+    assert str(tbra) == '<psi;t|'
+    assert pretty(tbra) == '<psi;t|'
+    assert upretty(tbra) == '⟨ψ;t❘'
+    assert latex(tbra) == r'{\left\langle \psi;t\right|}'
+    sT(tbra, "TimeDepBra(Symbol('psi'),Symbol('t'))")
+    assert str(tket) == '|psi;t>'
+    assert pretty(tket) == '|psi;t>'
+    assert upretty(tket) == '❘ψ;t⟩'
+    assert latex(tket) == r'{\left|\psi;t\right\rangle }'
+    sT(tket, "TimeDepKet(Symbol('psi'),Symbol('t'))")
+
+
+def test_tensorproduct():
+    tp = TensorProduct(JzKet(1, 1), JzKet(1, 0))
+    assert str(tp) == '|1,1>x|1,0>'
+    assert pretty(tp) == '|1,1>x |1,0>'
+    assert upretty(tp) == '❘1,1⟩⨂ ❘1,0⟩'
+    assert latex(tp) == \
+        r'{{\left|1,1\right\rangle }}\otimes {{\left|1,0\right\rangle }}'
+    sT(tp, "TensorProduct(JzKet(Integer(1),Integer(1)), JzKet(Integer(1),Integer(0)))")
+
+
+def test_big_expr():
+    f = Function('f')
+    x = symbols('x')
+    e1 = Dagger(AntiCommutator(Operator('A') + Operator('B'), Pow(DifferentialOperator(Derivative(f(x), x), f(x)), 3))*TensorProduct(Jz**2, Operator('A') + Operator('B')))*(JzBra(1, 0) + JzBra(1, 1))*(JzKet(0, 0) + JzKet(1, -1))
+    e2 = Commutator(Jz**2, Operator('A') + Operator('B'))*AntiCommutator(Dagger(Operator('C')*Operator('D')), Operator('E').inv()**2)*Dagger(Commutator(Jz, J2))
+    e3 = Wigner3j(1, 2, 3, 4, 5, 6)*TensorProduct(Commutator(Operator('A') + Dagger(Operator('B')), Operator('C') + Operator('D')), Jz - J2)*Dagger(OuterProduct(Dagger(JzBra(1, 1)), JzBra(1, 0)))*TensorProduct(JzKetCoupled(1, 1, (1, 1)) + JzKetCoupled(1, 0, (1, 1)), JzKetCoupled(1, -1, (1, 1)))
+    e4 = (ComplexSpace(1)*ComplexSpace(2) + FockSpace()**2)*(L2(Interval(
+        0, oo)) + HilbertSpace())
+    assert str(e1) == '(Jz**2)x(Dagger(A) + Dagger(B))*{Dagger(DifferentialOperator(Derivative(f(x), x),f(x)))**3,Dagger(A) + Dagger(B)}*(<1,0| + <1,1|)*(|0,0> + |1,-1>)'
+    ascii_str = \
+"""\
+                 /                                      3        \\                                 \n\
+                 |/                                   +\\         |                                 \n\
+    2  / +    +\\ <|                    /d            \\ |   +    +>                                 \n\
+/J \\ x \\A  + B /*||DifferentialOperator|--(f(x)),f(x)| | ,A  + B |*(<1,0| + <1,1|)*(|0,0> + |1,-1>)\n\
+\\ z/             \\\\                    \\dx           / /         /                                 \
+"""
+    ucode_str = \
+"""\
+                 ⎧                                      3        ⎫                                 \n\
+                 ⎪⎛                                   †⎞         ⎪                                 \n\
+    2  ⎛ †    †⎞ ⎨⎜                    ⎛d            ⎞ ⎟   †    †⎬                                 \n\
+⎛J ⎞ ⨂ ⎝A  + B ⎠⋅⎪⎜DifferentialOperator⎜──(f(x)),f(x)⎟ ⎟ ,A  + B ⎪⋅(⟨1,0❘ + ⟨1,1❘)⋅(❘0,0⟩ + ❘1,-1⟩)\n\
+⎝ z⎠             ⎩⎝                    ⎝dx           ⎠ ⎠         ⎭                                 \
+"""
+    assert pretty(e1) == ascii_str
+    assert upretty(e1) == ucode_str
+    assert latex(e1) == \
+        r'{J_z^{2}}\otimes \left({A^{\dagger} + B^{\dagger}}\right) \left\{\left(DifferentialOperator\left(\frac{d}{d x} f{\left(x \right)},f{\left(x \right)}\right)^{\dagger}\right)^{3},A^{\dagger} + B^{\dagger}\right\} \left({\left\langle 1,0\right|} + {\left\langle 1,1\right|}\right) \left({\left|0,0\right\rangle } + {\left|1,-1\right\rangle }\right)'
+    sT(e1, "Mul(TensorProduct(Pow(JzOp(Symbol('J')), Integer(2)), Add(Dagger(Operator(Symbol('A'))), Dagger(Operator(Symbol('B'))))), AntiCommutator(Pow(Dagger(DifferentialOperator(Derivative(Function('f')(Symbol('x')), Tuple(Symbol('x'), Integer(1))),Function('f')(Symbol('x')))), Integer(3)),Add(Dagger(Operator(Symbol('A'))), Dagger(Operator(Symbol('B'))))), Add(JzBra(Integer(1),Integer(0)), JzBra(Integer(1),Integer(1))), Add(JzKet(Integer(0),Integer(0)), JzKet(Integer(1),Integer(-1))))")
+    assert str(e2) == '[Jz**2,A + B]*{E**(-2),Dagger(D)*Dagger(C)}*[J2,Jz]'
+    ascii_str = \
+"""\
+[    2      ] / -2  +  +\\ [ 2   ]\n\
+[/J \\ ,A + B]*<E  ,D *C >*[J ,J ]\n\
+[\\ z/       ] \\         / [    z]\
+"""
+    ucode_str = \
+"""\
+⎡    2      ⎤ ⎧ -2  †  †⎫ ⎡ 2   ⎤\n\
+⎢⎛J ⎞ ,A + B⎥⋅⎨E  ,D ⋅C ⎬⋅⎢J ,J ⎥\n\
+⎣⎝ z⎠       ⎦ ⎩         ⎭ ⎣    z⎦\
+"""
+    assert pretty(e2) == ascii_str
+    assert upretty(e2) == ucode_str
+    assert latex(e2) == \
+        r'\left[J_z^{2},A + B\right] \left\{E^{-2},D^{\dagger} C^{\dagger}\right\} \left[J^2,J_z\right]'
+    sT(e2, "Mul(Commutator(Pow(JzOp(Symbol('J')), Integer(2)),Add(Operator(Symbol('A')), Operator(Symbol('B')))), AntiCommutator(Pow(Operator(Symbol('E')), Integer(-2)),Mul(Dagger(Operator(Symbol('D'))), Dagger(Operator(Symbol('C'))))), Commutator(J2Op(Symbol('J')),JzOp(Symbol('J'))))")
+    assert str(e3) == \
+        "Wigner3j(1, 2, 3, 4, 5, 6)*[Dagger(B) + A,C + D]x(-J2 + Jz)*|1,0><1,1|*(|1,0,j1=1,j2=1> + |1,1,j1=1,j2=1>)x|1,-1,j1=1,j2=1>"
+    ascii_str = \
+"""\
+          [ +          ]  /   2     \\                                                                 \n\
+/1  3  5\\*[B  + A,C + D]x |- J  + J |*|1,0><1,1|*(|1,0,j1=1,j2=1> + |1,1,j1=1,j2=1>)x |1,-1,j1=1,j2=1>\n\
+|       |                 \\        z/                                                                 \n\
+\\2  4  6/                                                                                             \
+"""
+    ucode_str = \
+"""\
+          ⎡ †          ⎤  ⎛   2     ⎞                                                                 \n\
+⎛1  3  5⎞⋅⎣B  + A,C + D⎦⨂ ⎜- J  + J ⎟⋅❘1,0⟩⟨1,1❘⋅(❘1,0,j₁=1,j₂=1⟩ + ❘1,1,j₁=1,j₂=1⟩)⨂ ❘1,-1,j₁=1,j₂=1⟩\n\
+⎜       ⎟                 ⎝        z⎠                                                                 \n\
+⎝2  4  6⎠                                                                                             \
+"""
+    assert pretty(e3) == ascii_str
+    assert upretty(e3) == ucode_str
+    assert latex(e3) == \
+        r'\left(\begin{array}{ccc} 1 & 3 & 5 \\ 2 & 4 & 6 \end{array}\right) {\left[B^{\dagger} + A,C + D\right]}\otimes \left({- J^2 + J_z}\right) {\left|1,0\right\rangle }{\left\langle 1,1\right|} \left({{\left|1,0,j_{1}=1,j_{2}=1\right\rangle } + {\left|1,1,j_{1}=1,j_{2}=1\right\rangle }}\right)\otimes {{\left|1,-1,j_{1}=1,j_{2}=1\right\rangle }}'
+    sT(e3, "Mul(Wigner3j(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6)), TensorProduct(Commutator(Add(Dagger(Operator(Symbol('B'))), Operator(Symbol('A'))),Add(Operator(Symbol('C')), Operator(Symbol('D')))), Add(Mul(Integer(-1), J2Op(Symbol('J'))), JzOp(Symbol('J')))), OuterProduct(JzKet(Integer(1),Integer(0)),JzBra(Integer(1),Integer(1))), TensorProduct(Add(JzKetCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1)))), JzKetCoupled(Integer(1),Integer(1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))), JzKetCoupled(Integer(1),Integer(-1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))))")
+    assert str(e4) == '(C(1)*C(2)+F**2)*(L2(Interval(0, oo))+H)'
+    ascii_str = \
+"""\
+// 1    2\\    x2\\   / 2    \\\n\
+\\\\C  x C / + F  / x \\L  + H/\
+"""
+    ucode_str = \
+"""\
+⎛⎛ 1    2⎞    ⨂2⎞   ⎛ 2    ⎞\n\
+⎝⎝C  ⨂ C ⎠ ⊕ F  ⎠ ⨂ ⎝L  ⊕ H⎠\
+"""
+    assert pretty(e4) == ascii_str
+    assert upretty(e4) == ucode_str
+    assert latex(e4) == \
+        r'\left(\left(\mathcal{C}^{1}\otimes \mathcal{C}^{2}\right)\oplus {\mathcal{F}}^{\otimes 2}\right)\otimes \left({\mathcal{L}^2}\left( \left[0, \infty\right) \right)\oplus \mathcal{H}\right)'
+    sT(e4, "TensorProductHilbertSpace((DirectSumHilbertSpace(TensorProductHilbertSpace(ComplexSpace(Integer(1)),ComplexSpace(Integer(2))),TensorPowerHilbertSpace(FockSpace(),Integer(2)))),(DirectSumHilbertSpace(L2(Interval(Integer(0), oo, false, true)),HilbertSpace())))")
+
+
+def _test_sho1d():
+    ad = RaisingOp('a')
+    assert pretty(ad) == ' \N{DAGGER}\na '
+    assert latex(ad) == 'a^{\\dagger}'

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_qapply.py

@@ -0,0 +1,152 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Integer, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+
+from sympy.physics.quantum.anticommutator import AntiCommutator
+from sympy.physics.quantum.commutator import Commutator
+from sympy.physics.quantum.constants import hbar
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.gate import H, XGate, IdentityGate
+from sympy.physics.quantum.operator import Operator, IdentityOperator
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.spin import Jx, Jy, Jz, Jplus, Jminus, J2, JzKet
+from sympy.physics.quantum.tensorproduct import TensorProduct
+from sympy.physics.quantum.state import Ket
+from sympy.physics.quantum.density import Density
+from sympy.physics.quantum.qubit import Qubit, QubitBra
+from sympy.physics.quantum.boson import BosonOp, BosonFockKet, BosonFockBra
+from sympy.testing.pytest import warns_deprecated_sympy
+
+
+j, jp, m, mp = symbols("j j' m m'")
+
+z = JzKet(1, 0)
+po = JzKet(1, 1)
+mo = JzKet(1, -1)
+
+A = Operator('A')
+
+
+class Foo(Operator):
+    def _apply_operator_JzKet(self, ket, **options):
+        return ket
+
+
+def test_basic():
+    assert qapply(Jz*po) == hbar*po
+    assert qapply(Jx*z) == hbar*po/sqrt(2) + hbar*mo/sqrt(2)
+    assert qapply((Jplus + Jminus)*z/sqrt(2)) == hbar*po + hbar*mo
+    assert qapply(Jz*(po + mo)) == hbar*po - hbar*mo
+    assert qapply(Jz*po + Jz*mo) == hbar*po - hbar*mo
+    assert qapply(Jminus*Jminus*po) == 2*hbar**2*mo
+    assert qapply(Jplus**2*mo) == 2*hbar**2*po
+    assert qapply(Jplus**2*Jminus**2*po) == 4*hbar**4*po
+
+
+def test_extra():
+    extra = z.dual*A*z
+    assert qapply(Jz*po*extra) == hbar*po*extra
+    assert qapply(Jx*z*extra) == (hbar*po/sqrt(2) + hbar*mo/sqrt(2))*extra
+    assert qapply(
+        (Jplus + Jminus)*z/sqrt(2)*extra) == hbar*po*extra + hbar*mo*extra
+    assert qapply(Jz*(po + mo)*extra) == hbar*po*extra - hbar*mo*extra
+    assert qapply(Jz*po*extra + Jz*mo*extra) == hbar*po*extra - hbar*mo*extra
+    assert qapply(Jminus*Jminus*po*extra) == 2*hbar**2*mo*extra
+    assert qapply(Jplus**2*mo*extra) == 2*hbar**2*po*extra
+    assert qapply(Jplus**2*Jminus**2*po*extra) == 4*hbar**4*po*extra
+
+
+def test_innerproduct():
+    assert qapply(po.dual*Jz*po, ip_doit=False) == hbar*(po.dual*po)
+    assert qapply(po.dual*Jz*po) == hbar
+
+
+def test_zero():
+    assert qapply(0) == 0
+    assert qapply(Integer(0)) == 0
+
+
+def test_commutator():
+    assert qapply(Commutator(Jx, Jy)*Jz*po) == I*hbar**3*po
+    assert qapply(Commutator(J2, Jz)*Jz*po) == 0
+    assert qapply(Commutator(Jz, Foo('F'))*po) == 0
+    assert qapply(Commutator(Foo('F'), Jz)*po) == 0
+
+
+def test_anticommutator():
+    assert qapply(AntiCommutator(Jz, Foo('F'))*po) == 2*hbar*po
+    assert qapply(AntiCommutator(Foo('F'), Jz)*po) == 2*hbar*po
+
+
+def test_outerproduct():
+    e = Jz*(mo*po.dual)*Jz*po
+    assert qapply(e) == -hbar**2*mo
+    assert qapply(e, ip_doit=False) == -hbar**2*(po.dual*po)*mo
+    assert qapply(e).doit() == -hbar**2*mo
+
+
+def test_tensorproduct():
+    a = BosonOp("a")
+    b = BosonOp("b")
+    ket1 = TensorProduct(BosonFockKet(1), BosonFockKet(2))
+    ket2 = TensorProduct(BosonFockKet(0), BosonFockKet(0))
+    ket3 = TensorProduct(BosonFockKet(0), BosonFockKet(2))
+    bra1 = TensorProduct(BosonFockBra(0), BosonFockBra(0))
+    bra2 = TensorProduct(BosonFockBra(1), BosonFockBra(2))
+    assert qapply(TensorProduct(a, b ** 2) * ket1) == sqrt(2) * ket2
+    assert qapply(TensorProduct(a, Dagger(b) * b) * ket1) == 2 * ket3
+    assert qapply(bra1 * TensorProduct(a, b * b),
+                  dagger=True) == sqrt(2) * bra2
+    assert qapply(bra2 * ket1).doit() == S.One
+    assert qapply(TensorProduct(a, b * b) * ket1) == sqrt(2) * ket2
+    assert qapply(Dagger(TensorProduct(a, b * b) * ket1),
+                  dagger=True) == sqrt(2) * Dagger(ket2)
+
+
+def test_dagger():
+    lhs = Dagger(Qubit(0))*Dagger(H(0))
+    rhs = Dagger(Qubit(1))/sqrt(2) + Dagger(Qubit(0))/sqrt(2)
+    assert qapply(lhs, dagger=True) == rhs
+
+
+def test_issue_6073():
+    x, y = symbols('x y', commutative=False)
+    A = Ket(x, y)
+    B = Operator('B')
+    assert qapply(A) == A
+    assert qapply(A.dual*B) == A.dual*B
+
+
+def test_density():
+    d = Density([Jz*mo, 0.5], [Jz*po, 0.5])
+    assert qapply(d) == Density([-hbar*mo, 0.5], [hbar*po, 0.5])
+
+
+def test_issue3044():
+    expr1 = TensorProduct(Jz*JzKet(S(2),S.NegativeOne)/sqrt(2), Jz*JzKet(S.Half,S.Half))
+    result = Mul(S.NegativeOne, Rational(1, 4), 2**S.Half, hbar**2)
+    result *= TensorProduct(JzKet(2,-1), JzKet(S.Half,S.Half))
+    assert qapply(expr1) == result
+
+
+# Issue 24158: Tests whether qapply incorrectly evaluates some ket*op as op*ket
+def test_issue24158_ket_times_op():
+    P = BosonFockKet(0) * BosonOp("a") # undefined term
+    # Does lhs._apply_operator_BosonOp(rhs) still evaluate ket*op as op*ket?
+    assert qapply(P) == P   # qapply(P) -> BosonOp("a")*BosonFockKet(0) = 0 before fix
+    P = Qubit(1) * XGate(0) # undefined term
+    # Does rhs._apply_operator_Qubit(lhs) still evaluate ket*op as op*ket?
+    assert qapply(P) == P   # qapply(P) -> Qubit(0) before fix
+    P1 = Mul(QubitBra(0), Mul(QubitBra(0), Qubit(0)), XGate(0)) # legal expr <0| * (<1|*|1>) * X
+    assert qapply(P1) == QubitBra(0) * XGate(0)     # qapply(P1) -> 0 before fix
+    P1 = qapply(P1, dagger = True)  # unsatisfactorily -> <0|*X(0), expect <1| since dagger=True
+    assert qapply(P1, dagger = True) == QubitBra(1) # qapply(P1, dagger=True) -> 0 before fix
+    P2 = QubitBra(0) * (QubitBra(0) * Qubit(0)) * XGate(0) # 'forgot' to set brackets
+    P2 = qapply(P2, dagger = True) # unsatisfactorily -> <0|*X(0), expect <1| since dagger=True
+    assert P2 == QubitBra(1) # qapply(P1) -> 0 before fix
+    # Pull Request 24237: IdentityOperator from the right without dagger=True option
+    with warns_deprecated_sympy():
+        assert qapply(QubitBra(1)*IdentityOperator()) == QubitBra(1)
+        assert qapply(IdentityGate(0)*(Qubit(0) + Qubit(1))) == Qubit(0) + Qubit(1)

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_qasm.py

@@ -0,0 +1,89 @@
+from sympy.physics.quantum.qasm import Qasm, flip_index, trim,\
+     get_index, nonblank, fullsplit, fixcommand, stripquotes, read_qasm
+from sympy.physics.quantum.gate import X, Z, H, S, T
+from sympy.physics.quantum.gate import CNOT, SWAP, CPHASE, CGate, CGateS
+from sympy.physics.quantum.circuitplot import Mz
+
+def test_qasm_readqasm():
+    qasm_lines = """\
+    qubit q_0
+    qubit q_1
+    h q_0
+    cnot q_0,q_1
+    """
+    q = read_qasm(qasm_lines)
+    assert q.get_circuit() == CNOT(1,0)*H(1)
+
+def test_qasm_ex1():
+    q = Qasm('qubit q0', 'qubit q1', 'h q0', 'cnot q0,q1')
+    assert q.get_circuit() == CNOT(1,0)*H(1)
+
+def test_qasm_ex1_methodcalls():
+    q = Qasm()
+    q.qubit('q_0')
+    q.qubit('q_1')
+    q.h('q_0')
+    q.cnot('q_0', 'q_1')
+    assert q.get_circuit() == CNOT(1,0)*H(1)
+
+def test_qasm_swap():
+    q = Qasm('qubit q0', 'qubit q1', 'cnot q0,q1', 'cnot q1,q0', 'cnot q0,q1')
+    assert q.get_circuit() == CNOT(1,0)*CNOT(0,1)*CNOT(1,0)
+
+
+def test_qasm_ex2():
+    q = Qasm('qubit q_0', 'qubit q_1', 'qubit q_2', 'h  q_1',
+             'cnot q_1,q_2', 'cnot q_0,q_1', 'h q_0',
+             'measure q_1', 'measure q_0',
+             'c-x q_1,q_2', 'c-z q_0,q_2')
+    assert q.get_circuit() == CGate(2,Z(0))*CGate(1,X(0))*Mz(2)*Mz(1)*H(2)*CNOT(2,1)*CNOT(1,0)*H(1)
+
+def test_qasm_1q():
+    for symbol, gate in [('x', X), ('z', Z), ('h', H), ('s', S), ('t', T), ('measure', Mz)]:
+        q = Qasm('qubit q_0', '%s q_0' % symbol)
+        assert q.get_circuit() == gate(0)
+
+def test_qasm_2q():
+    for symbol, gate in [('cnot', CNOT), ('swap', SWAP), ('cphase', CPHASE)]:
+        q = Qasm('qubit q_0', 'qubit q_1', '%s q_0,q_1' % symbol)
+        assert q.get_circuit() == gate(1,0)
+
+def test_qasm_3q():
+    q = Qasm('qubit q0', 'qubit q1', 'qubit q2', 'toffoli q2,q1,q0')
+    assert q.get_circuit() == CGateS((0,1),X(2))
+
+def test_qasm_flip_index():
+    assert flip_index(0, 2) == 1
+    assert flip_index(1, 2) == 0
+
+def test_qasm_trim():
+    assert trim('nothing happens here') == 'nothing happens here'
+    assert trim("Something #happens here") == "Something "
+
+def test_qasm_get_index():
+    assert get_index('q0', ['q0', 'q1']) == 1
+    assert get_index('q1', ['q0', 'q1']) == 0
+
+def test_qasm_nonblank():
+    assert list(nonblank('abcd')) == list('abcd')
+    assert list(nonblank('abc ')) == list('abc')
+
+def test_qasm_fullsplit():
+    assert fullsplit('g q0,q1,q2,  q3') == ('g', ['q0', 'q1', 'q2', 'q3'])
+
+def test_qasm_fixcommand():
+    assert fixcommand('foo') == 'foo'
+    assert fixcommand('def') == 'qdef'
+
+def test_qasm_stripquotes():
+    assert stripquotes("'S'") == 'S'
+    assert stripquotes('"S"') == 'S'
+    assert stripquotes('S') == 'S'
+
+def test_qasm_qdef():
+    # weaker test condition (str) since we don't have access to the actual class
+    q = Qasm("def Q,0,Q",'qubit q0','Q q0')
+    assert str(q.get_circuit()) == 'Q(0)'
+
+    q = Qasm("def CQ,1,Q", 'qubit q0', 'qubit q1', 'CQ q0,q1')
+    assert str(q.get_circuit()) == 'C((1),Q(0))'

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_qexpr.py

@@ -0,0 +1,64 @@
+from sympy.core.numbers import Integer
+from sympy.core.symbol import Symbol
+from sympy.concrete import Sum
+from sympy.physics.quantum.qexpr import QExpr, _qsympify_sequence
+from sympy.physics.quantum.hilbert import HilbertSpace
+from sympy.core.containers import Tuple
+
+x = Symbol('x')
+y = Symbol('y')
+n = Symbol('n', integer=True)
+m = Symbol('m', integer=True)
+
+
+def test_qexpr_new():
+    q = QExpr(0)
+    assert q.label == (0,)
+    assert q.hilbert_space == HilbertSpace()
+    assert q.is_commutative is False
+
+    q = QExpr(0, 1)
+    assert q.label == (Integer(0), Integer(1))
+
+    q = QExpr._new_rawargs(HilbertSpace(), Integer(0), Integer(1))
+    assert q.label == (Integer(0), Integer(1))
+    assert q.hilbert_space == HilbertSpace()
+
+
+def test_qexpr_commutative():
+    q1 = QExpr(x)
+    q2 = QExpr(y)
+    assert q1.is_commutative is False
+    assert q2.is_commutative is False
+    assert q1*q2 != q2*q1
+
+    q = QExpr._new_rawargs(Integer(0), Integer(1), HilbertSpace())
+    assert q.is_commutative is False
+
+
+def test_qexpr_free_symbols():
+    q1 = QExpr(x, y)
+    assert q1.free_symbols == {x, y}
+
+
+def test_qexpr_sum():
+    q1 = Sum(QExpr(n), (n,0,2))
+    assert q1.doit() == QExpr(0) + QExpr(1) + QExpr(2)
+
+    q2 = Sum(QExpr(n, m), (n, 0, 2), (m, 0, 2))
+    assert q2.doit() == QExpr(0, 0) + QExpr(0, 1) + QExpr(0, 2) + \
+        QExpr(1, 0) + QExpr(1, 1) + QExpr(1, 2) + \
+        QExpr(2, 0) + QExpr(2, 1) + QExpr(2, 2)
+
+
+def test_qexpr_subs():
+    q1 = QExpr(x, y)
+    assert q1.subs(x, y) == QExpr(y, y)
+    assert q1.subs({x: 1, y: 2}) == QExpr(1, 2)
+
+
+def test_qsympify():
+    assert _qsympify_sequence([[1, 2], [1, 3]]) == (Tuple(1, 2), Tuple(1, 3))
+    assert _qsympify_sequence(([1, 2, [3, 4, [2, ]], 1], 3)) == \
+        (Tuple(1, 2, Tuple(3, 4, Tuple(2,)), 1), 3)
+    assert _qsympify_sequence((1,)) == (1,)

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_qft.py

@@ -0,0 +1,52 @@
+from sympy.core.numbers import (I, pi)
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+
+from sympy.physics.quantum.qft import QFT, IQFT, RkGate
+from sympy.physics.quantum.gate import (ZGate, SwapGate, HadamardGate, CGate,
+                                        PhaseGate, TGate)
+from sympy.physics.quantum.qubit import Qubit
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.represent import represent
+
+from sympy.functions.elementary.complexes import sign
+
+
+def test_RkGate():
+    x = Symbol('x')
+    assert RkGate(1, x).k == x
+    assert RkGate(1, x).targets == (1,)
+    assert RkGate(1, 1) == ZGate(1)
+    assert RkGate(2, 2) == PhaseGate(2)
+    assert RkGate(3, 3) == TGate(3)
+
+    assert represent(
+        RkGate(0, x), nqubits=1) == Matrix([[1, 0], [0, exp(sign(x)*2*pi*I/(2**abs(x)))]])
+
+
+def test_quantum_fourier():
+    assert QFT(0, 3).decompose() == \
+        SwapGate(0, 2)*HadamardGate(0)*CGate((0,), PhaseGate(1)) * \
+        HadamardGate(1)*CGate((0,), TGate(2))*CGate((1,), PhaseGate(2)) * \
+        HadamardGate(2)
+
+    assert IQFT(0, 3).decompose() == \
+        HadamardGate(2)*CGate((1,), RkGate(2, -2))*CGate((0,), RkGate(2, -3)) * \
+        HadamardGate(1)*CGate((0,), RkGate(1, -2))*HadamardGate(0)*SwapGate(0, 2)
+
+    assert represent(QFT(0, 3), nqubits=3) == \
+        Matrix([[exp(2*pi*I/8)**(i*j % 8)/sqrt(8) for i in range(8)] for j in range(8)])
+
+    assert QFT(0, 4).decompose()  # non-trivial decomposition
+    assert qapply(QFT(0, 3).decompose()*Qubit(0, 0, 0)).expand() == qapply(
+        HadamardGate(0)*HadamardGate(1)*HadamardGate(2)*Qubit(0, 0, 0)
+    ).expand()
+
+
+def test_qft_represent():
+    c = QFT(0, 3)
+    a = represent(c, nqubits=3)
+    b = represent(c.decompose(), nqubits=3)
+    assert a.evalf(n=10) == b.evalf(n=10)

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_qubit.py

@@ -0,0 +1,264 @@
+import random
+
+from sympy.core.numbers import (Integer, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+from sympy.physics.quantum.qubit import (measure_all, measure_all_oneshot, measure_partial,
+                                         matrix_to_qubit, matrix_to_density,
+                                         qubit_to_matrix, IntQubit,
+                                         IntQubitBra, QubitBra)
+from sympy.physics.quantum.gate import (HadamardGate, CNOT, XGate, YGate,
+                                        ZGate, PhaseGate)
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.represent import represent
+from sympy.physics.quantum.shor import Qubit
+from sympy.testing.pytest import raises
+from sympy.physics.quantum.density import Density
+from sympy.physics.quantum.trace import Tr
+
+x, y = symbols('x,y')
+
+epsilon = .000001
+
+
+def test_Qubit():
+    array = [0, 0, 1, 1, 0]
+    qb = Qubit('00110')
+    assert qb.flip(0) == Qubit('00111')
+    assert qb.flip(1) == Qubit('00100')
+    assert qb.flip(4) == Qubit('10110')
+    assert qb.qubit_values == (0, 0, 1, 1, 0)
+    assert qb.dimension == 5
+    for i in range(5):
+        assert qb[i] == array[4 - i]
+    assert len(qb) == 5
+    qb = Qubit('110')
+
+
+def test_QubitBra():
+    qb = Qubit(0)
+    qb_bra = QubitBra(0)
+    assert qb.dual_class() == QubitBra
+    assert qb_bra.dual_class() == Qubit
+
+    qb = Qubit(1, 1, 0)
+    qb_bra = QubitBra(1, 1, 0)
+    assert represent(qb, nqubits=3).H == represent(qb_bra, nqubits=3)
+
+    qb = Qubit(0, 1)
+    qb_bra = QubitBra(1,0)
+    assert qb._eval_innerproduct_QubitBra(qb_bra) == Integer(0)
+
+    qb_bra = QubitBra(0, 1)
+    assert qb._eval_innerproduct_QubitBra(qb_bra) == Integer(1)
+
+
+def test_IntQubit():
+    # issue 9136
+    iqb = IntQubit(0, nqubits=1)
+    assert qubit_to_matrix(Qubit('0')) == qubit_to_matrix(iqb)
+
+    qb = Qubit('1010')
+    assert qubit_to_matrix(IntQubit(qb)) == qubit_to_matrix(qb)
+
+    iqb = IntQubit(1, nqubits=1)
+    assert qubit_to_matrix(Qubit('1')) == qubit_to_matrix(iqb)
+    assert qubit_to_matrix(IntQubit(1)) == qubit_to_matrix(iqb)
+
+    iqb = IntQubit(7, nqubits=4)
+    assert qubit_to_matrix(Qubit('0111')) == qubit_to_matrix(iqb)
+    assert qubit_to_matrix(IntQubit(7, 4)) == qubit_to_matrix(iqb)
+
+    iqb = IntQubit(8)
+    assert iqb.as_int() == 8
+    assert iqb.qubit_values == (1, 0, 0, 0)
+
+    iqb = IntQubit(7, 4)
+    assert iqb.qubit_values == (0, 1, 1, 1)
+    assert IntQubit(3) == IntQubit(3, 2)
+
+    #test Dual Classes
+    iqb = IntQubit(3)
+    iqb_bra = IntQubitBra(3)
+    assert iqb.dual_class() == IntQubitBra
+    assert iqb_bra.dual_class() == IntQubit
+
+    iqb = IntQubit(5)
+    iqb_bra = IntQubitBra(5)
+    assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(1)
+
+    iqb = IntQubit(4)
+    iqb_bra = IntQubitBra(5)
+    assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(0)
+    raises(ValueError, lambda: IntQubit(4, 1))
+
+    raises(ValueError, lambda: IntQubit('5'))
+    raises(ValueError, lambda: IntQubit(5, '5'))
+    raises(ValueError, lambda: IntQubit(5, nqubits='5'))
+    raises(TypeError, lambda: IntQubit(5, bad_arg=True))
+
+def test_superposition_of_states():
+    state = 1/sqrt(2)*Qubit('01') + 1/sqrt(2)*Qubit('10')
+    state_gate = CNOT(0, 1)*HadamardGate(0)*state
+    state_expanded = Qubit('01')/2 + Qubit('00')/2 - Qubit('11')/2 + Qubit('10')/2
+    assert qapply(state_gate).expand() == state_expanded
+    assert matrix_to_qubit(represent(state_gate, nqubits=2)) == state_expanded
+
+
+#test apply methods
+def test_apply_represent_equality():
+    gates = [HadamardGate(int(3*random.random())),
+     XGate(int(3*random.random())), ZGate(int(3*random.random())),
+        YGate(int(3*random.random())), ZGate(int(3*random.random())),
+        PhaseGate(int(3*random.random()))]
+
+    circuit = Qubit(int(random.random()*2), int(random.random()*2),
+    int(random.random()*2), int(random.random()*2), int(random.random()*2),
+        int(random.random()*2))
+    for i in range(int(random.random()*6)):
+        circuit = gates[int(random.random()*6)]*circuit
+
+    mat = represent(circuit, nqubits=6)
+    states = qapply(circuit)
+    state_rep = matrix_to_qubit(mat)
+    states = states.expand()
+    state_rep = state_rep.expand()
+    assert state_rep == states
+
+
+def test_matrix_to_qubits():
+    qb = Qubit(0, 0, 0, 0)
+    mat = Matrix([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    assert matrix_to_qubit(mat) == qb
+    assert qubit_to_matrix(qb) == mat
+
+    state = 2*sqrt(2)*(Qubit(0, 0, 0) + Qubit(0, 0, 1) + Qubit(0, 1, 0) +
+                       Qubit(0, 1, 1) + Qubit(1, 0, 0) + Qubit(1, 0, 1) +
+                       Qubit(1, 1, 0) + Qubit(1, 1, 1))
+    ones = sqrt(2)*2*Matrix([1, 1, 1, 1, 1, 1, 1, 1])
+    assert matrix_to_qubit(ones) == state.expand()
+    assert qubit_to_matrix(state) == ones
+
+
+def test_measure_normalize():
+    a, b = symbols('a b')
+    state = a*Qubit('110') + b*Qubit('111')
+    assert measure_partial(state, (0,), normalize=False) == \
+        [(a*Qubit('110'), a*a.conjugate()), (b*Qubit('111'), b*b.conjugate())]
+    assert measure_all(state, normalize=False) == \
+        [(Qubit('110'), a*a.conjugate()), (Qubit('111'), b*b.conjugate())]
+
+
+def test_measure_partial():
+    #Basic test of collapse of entangled two qubits (Bell States)
+    state = Qubit('01') + Qubit('10')
+    assert measure_partial(state, (0,)) == \
+        [(Qubit('10'), S.Half), (Qubit('01'), S.Half)]
+    assert measure_partial(state, int(0)) == \
+        [(Qubit('10'), S.Half), (Qubit('01'), S.Half)]
+    assert measure_partial(state, (0,)) == \
+        measure_partial(state, (1,))[::-1]
+
+    #Test of more complex collapse and probability calculation
+    state1 = sqrt(2)/sqrt(3)*Qubit('00001') + 1/sqrt(3)*Qubit('11111')
+    assert measure_partial(state1, (0,)) == \
+        [(sqrt(2)/sqrt(3)*Qubit('00001') + 1/sqrt(3)*Qubit('11111'), 1)]
+    assert measure_partial(state1, (1, 2)) == measure_partial(state1, (3, 4))
+    assert measure_partial(state1, (1, 2, 3)) == \
+        [(Qubit('00001'), Rational(2, 3)), (Qubit('11111'), Rational(1, 3))]
+
+    #test of measuring multiple bits at once
+    state2 = Qubit('1111') + Qubit('1101') + Qubit('1011') + Qubit('1000')
+    assert measure_partial(state2, (0, 1, 3)) == \
+        [(Qubit('1000'), Rational(1, 4)), (Qubit('1101'), Rational(1, 4)),
+         (Qubit('1011')/sqrt(2) + Qubit('1111')/sqrt(2), S.Half)]
+    assert measure_partial(state2, (0,)) == \
+        [(Qubit('1000'), Rational(1, 4)),
+         (Qubit('1111')/sqrt(3) + Qubit('1101')/sqrt(3) +
+          Qubit('1011')/sqrt(3), Rational(3, 4))]
+
+
+def test_measure_all():
+    assert measure_all(Qubit('11')) == [(Qubit('11'), 1)]
+    state = Qubit('11') + Qubit('10')
+    assert measure_all(state) == [(Qubit('10'), S.Half),
+           (Qubit('11'), S.Half)]
+    state2 = Qubit('11')/sqrt(5) + 2*Qubit('00')/sqrt(5)
+    assert measure_all(state2) == \
+        [(Qubit('00'), Rational(4, 5)), (Qubit('11'), Rational(1, 5))]
+
+    # from issue #12585
+    assert measure_all(qapply(Qubit('0'))) == [(Qubit('0'), 1)]
+
+
+def test_measure_all_oneshot():
+    random.seed(42)
+    # for issue #27092
+    assert measure_all_oneshot(Qubit('11')) == Qubit('11')
+    assert measure_all_oneshot(Qubit('1')) == Qubit('1')
+    assert measure_all_oneshot(Qubit('0')/sqrt(2) + Qubit('1')/sqrt(2)) == \
+            Qubit('0')
+
+
+def test_eval_trace():
+    q1 = Qubit('10110')
+    q2 = Qubit('01010')
+    d = Density([q1, 0.6], [q2, 0.4])
+
+    t = Tr(d)
+    assert t.doit() == 1.0
+
+    # extreme bits
+    t = Tr(d, 0)
+    assert t.doit() == (0.4*Density([Qubit('0101'), 1]) +
+                        0.6*Density([Qubit('1011'), 1]))
+    t = Tr(d, 4)
+    assert t.doit() == (0.4*Density([Qubit('1010'), 1]) +
+                        0.6*Density([Qubit('0110'), 1]))
+    # index somewhere in between
+    t = Tr(d, 2)
+    assert t.doit() == (0.4*Density([Qubit('0110'), 1]) +
+                        0.6*Density([Qubit('1010'), 1]))
+    #trace all indices
+    t = Tr(d, [0, 1, 2, 3, 4])
+    assert t.doit() == 1.0
+
+    # trace some indices, initialized in
+    # non-canonical order
+    t = Tr(d, [2, 1, 3])
+    assert t.doit() == (0.4*Density([Qubit('00'), 1]) +
+                        0.6*Density([Qubit('10'), 1]))
+
+    # mixed states
+    q = (1/sqrt(2)) * (Qubit('00') + Qubit('11'))
+    d = Density( [q, 1.0] )
+    t = Tr(d, 0)
+    assert t.doit() == (0.5*Density([Qubit('0'), 1]) +
+                        0.5*Density([Qubit('1'), 1]))
+
+
+def test_matrix_to_density():
+    mat = Matrix([[0, 0], [0, 1]])
+    assert matrix_to_density(mat) == Density([Qubit('1'), 1])
+
+    mat = Matrix([[1, 0], [0, 0]])
+    assert matrix_to_density(mat) == Density([Qubit('0'), 1])
+
+    mat = Matrix([[0, 0], [0, 0]])
+    assert matrix_to_density(mat) == 0
+
+    mat = Matrix([[0, 0, 0, 0],
+                  [0, 0, 0, 0],
+                  [0, 0, 1, 0],
+                  [0, 0, 0, 0]])
+
+    assert matrix_to_density(mat) == Density([Qubit('10'), 1])
+
+    mat = Matrix([[1, 0, 0, 0],
+                  [0, 0, 0, 0],
+                  [0, 0, 0, 0],
+                  [0, 0, 0, 0]])
+
+    assert matrix_to_density(mat) == Density([Qubit('00'), 1])

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_represent.py

@@ -0,0 +1,186 @@
+from sympy.core.numbers import (Float, I, Integer)
+from sympy.matrices.dense import Matrix
+from sympy.external import import_module
+from sympy.testing.pytest import skip
+
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.represent import (represent, rep_innerproduct,
+                                             rep_expectation, enumerate_states)
+from sympy.physics.quantum.state import Bra, Ket
+from sympy.physics.quantum.operator import Operator, OuterProduct
+from sympy.physics.quantum.tensorproduct import TensorProduct
+from sympy.physics.quantum.tensorproduct import matrix_tensor_product
+from sympy.physics.quantum.commutator import Commutator
+from sympy.physics.quantum.anticommutator import AntiCommutator
+from sympy.physics.quantum.innerproduct import InnerProduct
+from sympy.physics.quantum.matrixutils import (numpy_ndarray,
+                                               scipy_sparse_matrix, to_numpy,
+                                               to_scipy_sparse, to_sympy)
+from sympy.physics.quantum.cartesian import XKet, XOp, XBra
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.operatorset import operators_to_state
+from sympy.testing.pytest import raises
+
+Amat = Matrix([[1, I], [-I, 1]])
+Bmat = Matrix([[1, 2], [3, 4]])
+Avec = Matrix([[1], [I]])
+
+
+class AKet(Ket):
+
+    @classmethod
+    def dual_class(self):
+        return ABra
+
+    def _represent_default_basis(self, **options):
+        return self._represent_AOp(None, **options)
+
+    def _represent_AOp(self, basis, **options):
+        return Avec
+
+
+class ABra(Bra):
+
+    @classmethod
+    def dual_class(self):
+        return AKet
+
+
+class AOp(Operator):
+
+    def _represent_default_basis(self, **options):
+        return self._represent_AOp(None, **options)
+
+    def _represent_AOp(self, basis, **options):
+        return Amat
+
+
+class BOp(Operator):
+
+    def _represent_default_basis(self, **options):
+        return self._represent_AOp(None, **options)
+
+    def _represent_AOp(self, basis, **options):
+        return Bmat
+
+
+k = AKet('a')
+b = ABra('a')
+A = AOp('A')
+B = BOp('B')
+
+_tests = [
+    # Bra
+    (b, Dagger(Avec)),
+    (Dagger(b), Avec),
+    # Ket
+    (k, Avec),
+    (Dagger(k), Dagger(Avec)),
+    # Operator
+    (A, Amat),
+    (Dagger(A), Dagger(Amat)),
+    # OuterProduct
+    (OuterProduct(k, b), Avec*Avec.H),
+    # TensorProduct
+    (TensorProduct(A, B), matrix_tensor_product(Amat, Bmat)),
+    # Pow
+    (A**2, Amat**2),
+    # Add/Mul
+    (A*B + 2*A, Amat*Bmat + 2*Amat),
+    # Commutator
+    (Commutator(A, B), Amat*Bmat - Bmat*Amat),
+    # AntiCommutator
+    (AntiCommutator(A, B), Amat*Bmat + Bmat*Amat),
+    # InnerProduct
+    (InnerProduct(b, k), (Avec.H*Avec)[0])
+]
+
+
+def test_format_sympy():
+    for test in _tests:
+        lhs = represent(test[0], basis=A, format='sympy')
+        rhs = to_sympy(test[1])
+        assert lhs == rhs
+
+
+def test_scalar_sympy():
+    assert represent(Integer(1)) == Integer(1)
+    assert represent(Float(1.0)) == Float(1.0)
+    assert represent(1.0 + I) == 1.0 + I
+
+
+np = import_module('numpy')
+
+
+def test_format_numpy():
+    if not np:
+        skip("numpy not installed.")
+
+    for test in _tests:
+        lhs = represent(test[0], basis=A, format='numpy')
+        rhs = to_numpy(test[1])
+        if isinstance(lhs, numpy_ndarray):
+            assert (lhs == rhs).all()
+        else:
+            assert lhs == rhs
+
+
+def test_scalar_numpy():
+    if not np:
+        skip("numpy not installed.")
+
+    assert represent(Integer(1), format='numpy') == 1
+    assert represent(Float(1.0), format='numpy') == 1.0
+    assert represent(1.0 + I, format='numpy') == 1.0 + 1.0j
+
+
+scipy = import_module('scipy', import_kwargs={'fromlist': ['sparse']})
+
+
+def test_format_scipy_sparse():
+    if not np:
+        skip("numpy not installed.")
+    if not scipy:
+        skip("scipy not installed.")
+
+    for test in _tests:
+        lhs = represent(test[0], basis=A, format='scipy.sparse')
+        rhs = to_scipy_sparse(test[1])
+        if isinstance(lhs, scipy_sparse_matrix):
+            assert np.linalg.norm((lhs - rhs).todense()) == 0.0
+        else:
+            assert lhs == rhs
+
+
+def test_scalar_scipy_sparse():
+    if not np:
+        skip("numpy not installed.")
+    if not scipy:
+        skip("scipy not installed.")
+
+    assert represent(Integer(1), format='scipy.sparse') == 1
+    assert represent(Float(1.0), format='scipy.sparse') == 1.0
+    assert represent(1.0 + I, format='scipy.sparse') == 1.0 + 1.0j
+
+x_ket = XKet('x')
+x_bra = XBra('x')
+x_op = XOp('X')
+
+
+def test_innerprod_represent():
+    assert rep_innerproduct(x_ket) == InnerProduct(XBra("x_1"), x_ket).doit()
+    assert rep_innerproduct(x_bra) == InnerProduct(x_bra, XKet("x_1")).doit()
+    raises(TypeError, lambda: rep_innerproduct(x_op))
+
+
+def test_operator_represent():
+    basis_kets = enumerate_states(operators_to_state(x_op), 1, 2)
+    assert rep_expectation(
+        x_op) == qapply(basis_kets[1].dual*x_op*basis_kets[0])
+
+
+def test_enumerate_states():
+    test = XKet("foo")
+    assert enumerate_states(test, 1, 1) == [XKet("foo_1")]
+    assert enumerate_states(
+        test, [1, 2, 4]) == [XKet("foo_1"), XKet("foo_2"), XKet("foo_4")]

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_sho1d.py

@@ -0,0 +1,176 @@
+"""Tests for sho1d.py"""
+
+from sympy.concrete import Sum
+from sympy.core import oo
+from sympy.core.numbers import (I, Integer)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.physics.quantum import Dagger
+from sympy.physics.quantum.constants import hbar
+from sympy.physics.quantum import Commutator
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.innerproduct import InnerProduct
+from sympy.physics.quantum.cartesian import X, Px
+from sympy.physics.quantum.hilbert import ComplexSpace
+from sympy.physics.quantum.represent import represent
+from sympy.simplify import simplify
+from sympy.external import import_module
+from sympy.tensor import IndexedBase, Idx
+from sympy.testing.pytest import skip, raises
+
+from sympy.physics.quantum.sho1d import (RaisingOp, LoweringOp,
+                                        SHOKet, SHOBra,
+                                        Hamiltonian, NumberOp)
+
+ad = RaisingOp('a')
+a = LoweringOp('a')
+k = SHOKet('k')
+kz = SHOKet(0)
+kf = SHOKet(1)
+k3 = SHOKet(3)
+b = SHOBra('b')
+b3 = SHOBra(3)
+H = Hamiltonian('H')
+N = NumberOp('N')
+omega = Symbol('omega')
+m = Symbol('m')
+ndim = Integer(4)
+p = Symbol('p', integer=True)
+q = Symbol('q', nonnegative=True, integer=True)
+
+
+np = import_module('numpy')
+scipy = import_module('scipy', import_kwargs={'fromlist': ['sparse']})
+
+ad_rep_sympy = represent(ad, basis=N, ndim=4, format='sympy')
+a_rep = represent(a, basis=N, ndim=4, format='sympy')
+N_rep = represent(N, basis=N, ndim=4, format='sympy')
+H_rep = represent(H, basis=N, ndim=4, format='sympy')
+k3_rep = represent(k3, basis=N, ndim=4, format='sympy')
+b3_rep = represent(b3, basis=N, ndim=4, format='sympy')
+
+def test_RaisingOp():
+    assert Dagger(ad) == a
+    assert Commutator(ad, a).doit() == Integer(-1)
+    assert Commutator(ad, N).doit() == Integer(-1)*ad
+    assert qapply(ad*k) == (sqrt(k.n + 1)*SHOKet(k.n + 1)).expand()
+    assert qapply(ad*kz) == (sqrt(kz.n + 1)*SHOKet(kz.n + 1)).expand()
+    assert qapply(ad*kf) == (sqrt(kf.n + 1)*SHOKet(kf.n + 1)).expand()
+    assert ad.rewrite('xp').doit() == \
+        (Integer(1)/sqrt(Integer(2)*hbar*m*omega))*(Integer(-1)*I*Px + m*omega*X)
+    assert ad.hilbert_space == ComplexSpace(S.Infinity)
+    for i in range(ndim - 1):
+        assert ad_rep_sympy[i + 1,i] == sqrt(i + 1)
+
+    if not np:
+        skip("numpy not installed.")
+
+    ad_rep_numpy = represent(ad, basis=N, ndim=4, format='numpy')
+    for i in range(ndim - 1):
+        assert ad_rep_numpy[i + 1,i] == float(sqrt(i + 1))
+
+    if not np:
+        skip("numpy not installed.")
+    if not scipy:
+        skip("scipy not installed.")
+
+    ad_rep_scipy = represent(ad, basis=N, ndim=4, format='scipy.sparse', spmatrix='lil')
+    for i in range(ndim - 1):
+        assert ad_rep_scipy[i + 1,i] == float(sqrt(i + 1))
+
+    assert ad_rep_numpy.dtype == 'float64'
+    assert ad_rep_scipy.dtype == 'float64'
+
+def test_LoweringOp():
+    assert Dagger(a) == ad
+    assert Commutator(a, ad).doit() == Integer(1)
+    assert Commutator(a, N).doit() == a
+    assert qapply(a*k) == (sqrt(k.n)*SHOKet(k.n-Integer(1))).expand()
+    assert qapply(a*kz) == Integer(0)
+    assert qapply(a*kf) == (sqrt(kf.n)*SHOKet(kf.n-Integer(1))).expand()
+    assert a.rewrite('xp').doit() == \
+        (Integer(1)/sqrt(Integer(2)*hbar*m*omega))*(I*Px + m*omega*X)
+    for i in range(ndim - 1):
+        assert a_rep[i,i + 1] == sqrt(i + 1)
+
+def test_NumberOp():
+    assert Commutator(N, ad).doit() == ad
+    assert Commutator(N, a).doit() == Integer(-1)*a
+    assert Commutator(N, H).doit() == Integer(0)
+    assert qapply(N*k) == (k.n*k).expand()
+    assert N.rewrite('a').doit() == ad*a
+    assert N.rewrite('xp').doit() == (Integer(1)/(Integer(2)*m*hbar*omega))*(
+        Px**2 + (m*omega*X)**2) - Integer(1)/Integer(2)
+    assert N.rewrite('H').doit() == H/(hbar*omega) - Integer(1)/Integer(2)
+    for i in range(ndim):
+        assert N_rep[i,i] == i
+    assert N_rep == ad_rep_sympy*a_rep
+
+def test_Hamiltonian():
+    assert Commutator(H, N).doit() == Integer(0)
+    assert qapply(H*k) == ((hbar*omega*(k.n + Integer(1)/Integer(2)))*k).expand()
+    assert H.rewrite('a').doit() == hbar*omega*(ad*a + Integer(1)/Integer(2))
+    assert H.rewrite('xp').doit() == \
+        (Integer(1)/(Integer(2)*m))*(Px**2 + (m*omega*X)**2)
+    assert H.rewrite('N').doit() == hbar*omega*(N + Integer(1)/Integer(2))
+    for i in range(ndim):
+        assert H_rep[i,i] == hbar*omega*(i + Integer(1)/Integer(2))
+
+def test_SHOKet():
+    assert SHOKet('k').dual_class() == SHOBra
+    assert SHOBra('b').dual_class() == SHOKet
+    assert InnerProduct(b,k).doit() == KroneckerDelta(k.n, b.n)
+    assert k.hilbert_space == ComplexSpace(S.Infinity)
+    assert k3_rep[k3.n, 0] == Integer(1)
+    assert b3_rep[0, b3.n] == Integer(1)
+
+def test_sho_sums():
+    e1 = Sum(SHOKet(p)*SHOBra(p), (p, 0, 1))
+    assert e1.doit() == SHOKet(0)*SHOBra(0) + SHOKet(1)*SHOBra(1)
+
+    # Test qapply with Sum on the left
+    assert qapply(
+        Sum(SHOKet(p)*SHOBra(p), (p, 0, oo))*SHOKet(q),
+        sum_doit=True
+    ) == SHOKet(q)
+
+    # Test qapply with Sum on the right
+    a = IndexedBase('a')
+    n = symbols('n', cls=Idx)
+    result = qapply(SHOBra(q)*Sum(a[n]*SHOKet(n), (n,0,oo)), sum_doit=True)
+    assert result == a[q]
+
+    # Test qapply with a product of Sums
+    result = qapply(
+        SHOBra(q)*Sum(SHOKet(p)*SHOBra(p), (p, 0, oo))*Sum(a[n]*SHOKet(n), (n,0,oo)),
+        sum_doit=True
+    )
+    assert result == a[q]
+
+    with raises(ValueError):
+        result = qapply(
+            SHOBra(q)*Sum(SHOKet(p)*SHOBra(p), (p, 0, oo))*Sum(a[p]*SHOKet(p), (p,0,oo)),
+            sum_doit=True
+        )
+
+def test_sho_coherant_state():
+    alpha = Symbol('alpha', is_complex=True)
+    cstate = exp(-Abs(alpha)**2/S(2))*Sum(((alpha**p)/sqrt(factorial(p)))*SHOKet(p), (p,0,oo))
+    # Projection onto the number eigenstate
+    assert qapply(SHOBra(q)*cstate, sum_doit=True) == exp(-Abs(alpha)**2/S(2))*alpha**q/sqrt(factorial(q))
+    # Ensure that the coherent state is an eigenstate of annihilation operator
+    assert simplify(qapply(SHOBra(q)*a*cstate, sum_doit=True)) == simplify(qapply(SHOBra(q)*alpha*cstate, sum_doit=True))
+
+def test_issue_26495():
+    nbar = Symbol('nbar', real=True, nonnegative=True)
+    n = Symbol('n', integer=True)
+    i = Symbol('i', integer=True, nonnegative=True)
+    j = Symbol('j', integer=True, nonnegative=True)
+    rho = Sum((nbar/(1+nbar))**n*SHOKet(n)*SHOBra(n), (n,0,oo))
+    result = qapply(SHOBra(i)*rho*SHOKet(j), sum_doit=True)
+    assert simplify(result) == (nbar/(nbar+1))**i*KroneckerDelta(i,j)

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_shor.py

@@ -0,0 +1,21 @@
+from sympy.testing.pytest import XFAIL
+
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.qubit import Qubit
+from sympy.physics.quantum.shor import CMod, getr
+
+
+@XFAIL
+def test_CMod():
+    assert qapply(CMod(4, 2, 2)*Qubit(0, 0, 1, 0, 0, 0, 0, 0)) == \
+        Qubit(0, 0, 1, 0, 0, 0, 0, 0)
+    assert qapply(CMod(5, 5, 7)*Qubit(0, 0, 1, 0, 0, 0, 0, 0, 0, 0)) == \
+        Qubit(0, 0, 1, 0, 0, 0, 0, 0, 1, 0)
+    assert qapply(CMod(3, 2, 3)*Qubit(0, 1, 0, 0, 0, 0)) == \
+        Qubit(0, 1, 0, 0, 0, 1)
+
+
+def test_continued_frac():
+    assert getr(513, 1024, 10) == 2
+    assert getr(169, 1024, 11) == 6
+    assert getr(314, 4096, 16) == 13

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_state.py

@@ -0,0 +1,248 @@
+from sympy.core.add import Add
+from sympy.core.function import diff
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Integer, Rational, oo, pi)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.testing.pytest import raises
+
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.qexpr import QExpr
+from sympy.physics.quantum.state import (
+    Ket, Bra, TimeDepKet, TimeDepBra,
+    KetBase, BraBase, StateBase, Wavefunction,
+    OrthogonalKet, OrthogonalBra
+)
+from sympy.physics.quantum.hilbert import HilbertSpace
+
+x, y, t = symbols('x,y,t')
+
+
+class CustomKet(Ket):
+    @classmethod
+    def default_args(self):
+        return ("test",)
+
+
+class CustomKetMultipleLabels(Ket):
+    @classmethod
+    def default_args(self):
+        return ("r", "theta", "phi")
+
+
+class CustomTimeDepKet(TimeDepKet):
+    @classmethod
+    def default_args(self):
+        return ("test", "t")
+
+
+class CustomTimeDepKetMultipleLabels(TimeDepKet):
+    @classmethod
+    def default_args(self):
+        return ("r", "theta", "phi", "t")
+
+
+def test_ket():
+    k = Ket('0')
+
+    assert isinstance(k, Ket)
+    assert isinstance(k, KetBase)
+    assert isinstance(k, StateBase)
+    assert isinstance(k, QExpr)
+
+    assert k.label == (Symbol('0'),)
+    assert k.hilbert_space == HilbertSpace()
+    assert k.is_commutative is False
+
+    # Make sure this doesn't get converted to the number pi.
+    k = Ket('pi')
+    assert k.label == (Symbol('pi'),)
+
+    k = Ket(x, y)
+    assert k.label == (x, y)
+    assert k.hilbert_space == HilbertSpace()
+    assert k.is_commutative is False
+
+    assert k.dual_class() == Bra
+    assert k.dual == Bra(x, y)
+    assert k.subs(x, y) == Ket(y, y)
+
+    k = CustomKet()
+    assert k == CustomKet("test")
+
+    k = CustomKetMultipleLabels()
+    assert k == CustomKetMultipleLabels("r", "theta", "phi")
+
+    assert Ket() == Ket('psi')
+
+
+def test_bra():
+    b = Bra('0')
+
+    assert isinstance(b, Bra)
+    assert isinstance(b, BraBase)
+    assert isinstance(b, StateBase)
+    assert isinstance(b, QExpr)
+
+    assert b.label == (Symbol('0'),)
+    assert b.hilbert_space == HilbertSpace()
+    assert b.is_commutative is False
+
+    # Make sure this doesn't get converted to the number pi.
+    b = Bra('pi')
+    assert b.label == (Symbol('pi'),)
+
+    b = Bra(x, y)
+    assert b.label == (x, y)
+    assert b.hilbert_space == HilbertSpace()
+    assert b.is_commutative is False
+
+    assert b.dual_class() == Ket
+    assert b.dual == Ket(x, y)
+    assert b.subs(x, y) == Bra(y, y)
+
+    assert Bra() == Bra('psi')
+
+
+def test_ops():
+    k0 = Ket(0)
+    k1 = Ket(1)
+    k = 2*I*k0 - (x/sqrt(2))*k1
+    assert k == Add(Mul(2, I, k0),
+        Mul(Rational(-1, 2), x, Pow(2, S.Half), k1))
+
+
+def test_time_dep_ket():
+    k = TimeDepKet(0, t)
+
+    assert isinstance(k, TimeDepKet)
+    assert isinstance(k, KetBase)
+    assert isinstance(k, StateBase)
+    assert isinstance(k, QExpr)
+
+    assert k.label == (Integer(0),)
+    assert k.args == (Integer(0), t)
+    assert k.time == t
+
+    assert k.dual_class() == TimeDepBra
+    assert k.dual == TimeDepBra(0, t)
+
+    assert k.subs(t, 2) == TimeDepKet(0, 2)
+
+    k = TimeDepKet(x, 0.5)
+    assert k.label == (x,)
+    assert k.args == (x, sympify(0.5))
+
+    k = CustomTimeDepKet()
+    assert k.label == (Symbol("test"),)
+    assert k.time == Symbol("t")
+    assert k == CustomTimeDepKet("test", "t")
+
+    k = CustomTimeDepKetMultipleLabels()
+    assert k.label == (Symbol("r"), Symbol("theta"), Symbol("phi"))
+    assert k.time == Symbol("t")
+    assert k == CustomTimeDepKetMultipleLabels("r", "theta", "phi", "t")
+
+    assert TimeDepKet() == TimeDepKet("psi", "t")
+
+
+def test_time_dep_bra():
+    b = TimeDepBra(0, t)
+
+    assert isinstance(b, TimeDepBra)
+    assert isinstance(b, BraBase)
+    assert isinstance(b, StateBase)
+    assert isinstance(b, QExpr)
+
+    assert b.label == (Integer(0),)
+    assert b.args == (Integer(0), t)
+    assert b.time == t
+
+    assert b.dual_class() == TimeDepKet
+    assert b.dual == TimeDepKet(0, t)
+
+    k = TimeDepBra(x, 0.5)
+    assert k.label == (x,)
+    assert k.args == (x, sympify(0.5))
+
+    assert TimeDepBra() == TimeDepBra("psi", "t")
+
+
+def test_bra_ket_dagger():
+    x = symbols('x', complex=True)
+    k = Ket('k')
+    b = Bra('b')
+    assert Dagger(k) == Bra('k')
+    assert Dagger(b) == Ket('b')
+    assert Dagger(k).is_commutative is False
+
+    k2 = Ket('k2')
+    e = 2*I*k + x*k2
+    assert Dagger(e) == conjugate(x)*Dagger(k2) - 2*I*Dagger(k)
+
+
+def test_wavefunction():
+    x, y = symbols('x y', real=True)
+    L = symbols('L', positive=True)
+    n = symbols('n', integer=True, positive=True)
+
+    f = Wavefunction(x**2, x)
+    p = f.prob()
+    lims = f.limits
+
+    assert f.is_normalized is False
+    assert f.norm is oo
+    assert f(10) == 100
+    assert p(10) == 10000
+    assert lims[x] == (-oo, oo)
+    assert diff(f, x) == Wavefunction(2*x, x)
+    raises(NotImplementedError, lambda: f.normalize())
+    assert conjugate(f) == Wavefunction(conjugate(f.expr), x)
+    assert conjugate(f) == Dagger(f)
+
+    g = Wavefunction(x**2*y + y**2*x, (x, 0, 1), (y, 0, 2))
+    lims_g = g.limits
+
+    assert lims_g[x] == (0, 1)
+    assert lims_g[y] == (0, 2)
+    assert g.is_normalized is False
+    assert g.norm == sqrt(42)/3
+    assert g(2, 4) == 0
+    assert g(1, 1) == 2
+    assert diff(diff(g, x), y) == Wavefunction(2*x + 2*y, (x, 0, 1), (y, 0, 2))
+    assert conjugate(g) == Wavefunction(conjugate(g.expr), *g.args[1:])
+    assert conjugate(g) == Dagger(g)
+
+    h = Wavefunction(sqrt(5)*x**2, (x, 0, 1))
+    assert h.is_normalized is True
+    assert h.normalize() == h
+    assert conjugate(h) == Wavefunction(conjugate(h.expr), (x, 0, 1))
+    assert conjugate(h) == Dagger(h)
+
+    piab = Wavefunction(sin(n*pi*x/L), (x, 0, L))
+    assert piab.norm == sqrt(L/2)
+    assert piab(L + 1) == 0
+    assert piab(0.5) == sin(0.5*n*pi/L)
+    assert piab(0.5, n=1, L=1) == sin(0.5*pi)
+    assert piab.normalize() == \
+        Wavefunction(sqrt(2)/sqrt(L)*sin(n*pi*x/L), (x, 0, L))
+    assert conjugate(piab) == Wavefunction(conjugate(piab.expr), (x, 0, L))
+    assert conjugate(piab) == Dagger(piab)
+
+    k = Wavefunction(x**2, 'x')
+    assert type(k.variables[0]) == Symbol
+
+def test_orthogonal_states():
+    bracket = OrthogonalBra(x) * OrthogonalKet(x)
+    assert bracket.doit() == 1
+
+    bracket = OrthogonalBra(x) * OrthogonalKet(x+1)
+    assert bracket.doit() == 0
+
+    bracket = OrthogonalBra(x) * OrthogonalKet(y)
+    assert bracket.doit() == bracket

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_tensorproduct.py

@@ -0,0 +1,142 @@
+from sympy.core.numbers import I
+from sympy.core.symbol import symbols
+from sympy.core.expr import unchanged
+from sympy.matrices import Matrix, SparseMatrix, ImmutableMatrix
+from sympy.testing.pytest import warns_deprecated_sympy
+
+from sympy.physics.quantum.commutator import Commutator as Comm
+from sympy.physics.quantum.tensorproduct import TensorProduct
+from sympy.physics.quantum.tensorproduct import TensorProduct as TP
+from sympy.physics.quantum.tensorproduct import tensor_product_simp
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.qubit import Qubit, QubitBra
+from sympy.physics.quantum.operator import OuterProduct, Operator
+from sympy.physics.quantum.density import Density
+from sympy.physics.quantum.trace import Tr
+
+A = Operator('A')
+B = Operator('B')
+C = Operator('C')
+D = Operator('D')
+x = symbols('x')
+y = symbols('y', integer=True, positive=True)
+
+mat1 = Matrix([[1, 2*I], [1 + I, 3]])
+mat2 = Matrix([[2*I, 3], [4*I, 2]])
+
+
+def test_sparse_matrices():
+    spm = SparseMatrix.diag(1, 0)
+    assert unchanged(TensorProduct, spm, spm)
+
+
+def test_tensor_product_dagger():
+    assert Dagger(TensorProduct(I*A, B)) == \
+        -I*TensorProduct(Dagger(A), Dagger(B))
+    assert Dagger(TensorProduct(mat1, mat2)) == \
+        TensorProduct(Dagger(mat1), Dagger(mat2))
+
+
+def test_tensor_product_abstract():
+
+    assert TP(x*A, 2*B) == x*2*TP(A, B)
+    assert TP(A, B) != TP(B, A)
+    assert TP(A, B).is_commutative is False
+    assert isinstance(TP(A, B), TP)
+    assert TP(A, B).subs(A, C) == TP(C, B)
+
+
+def test_tensor_product_expand():
+    assert TP(A + B, B + C).expand(tensorproduct=True) == \
+        TP(A, B) + TP(A, C) + TP(B, B) + TP(B, C)
+    #Tests for fix of issue #24142
+    assert TP(A-B, B-A).expand(tensorproduct=True) == \
+        TP(A, B) - TP(A, A) - TP(B, B) + TP(B, A)
+    assert TP(2*A + B, A + B).expand(tensorproduct=True) == \
+        2 * TP(A, A) + 2 * TP(A, B) + TP(B, A) + TP(B, B)
+    assert TP(2 * A * B + A, A + B).expand(tensorproduct=True) == \
+        2 * TP(A*B, A) + 2 * TP(A*B, B) + TP(A, A) + TP(A, B)
+
+
+def test_tensor_product_commutator():
+    assert TP(Comm(A, B), C).doit().expand(tensorproduct=True) == \
+        TP(A*B, C) - TP(B*A, C)
+    assert Comm(TP(A, B), TP(B, C)).doit() == \
+        TP(A, B)*TP(B, C) - TP(B, C)*TP(A, B)
+
+
+def test_tensor_product_simp():
+    with warns_deprecated_sympy():
+        assert tensor_product_simp(TP(A, B)*TP(B, C)) == TP(A*B, B*C)
+        # tests for Pow-expressions
+        assert TP(A, B)**y == TP(A**y, B**y)
+        assert tensor_product_simp(TP(A, B)**y) == TP(A**y, B**y)
+        assert tensor_product_simp(x*TP(A, B)**2) == x*TP(A**2,B**2)
+        assert tensor_product_simp(x*(TP(A, B)**2)*TP(C,D)) == x*TP(A**2*C,B**2*D)
+        assert tensor_product_simp(TP(A,B)-TP(C,D)**y) == TP(A,B)-TP(C**y,D**y)
+
+
+def test_issue_5923():
+    # most of the issue regarding sympification of args has been handled
+    # and is tested internally by the use of args_cnc through the quantum
+    # module, but the following is a test from the issue that used to raise.
+    assert TensorProduct(1, Qubit('1')*Qubit('1').dual) == \
+        TensorProduct(1, OuterProduct(Qubit(1), QubitBra(1)))
+
+
+def test_eval_trace():
+    # This test includes tests with dependencies between TensorProducts
+    #and density operators. Since, the test is more to test the behavior of
+    #TensorProducts it remains here
+
+    # Density with simple tensor products as args
+    t = TensorProduct(A, B)
+    d = Density([t, 1.0])
+    tr = Tr(d)
+    assert tr.doit() == 1.0*Tr(A*Dagger(A))*Tr(B*Dagger(B))
+
+    ## partial trace with simple tensor products as args
+    t = TensorProduct(A, B, C)
+    d = Density([t, 1.0])
+    tr = Tr(d, [1])
+    assert tr.doit() == 1.0*A*Dagger(A)*Tr(B*Dagger(B))*C*Dagger(C)
+
+    tr = Tr(d, [0, 2])
+    assert tr.doit() == 1.0*Tr(A*Dagger(A))*B*Dagger(B)*Tr(C*Dagger(C))
+
+    # Density with multiple Tensorproducts as states
+    t2 = TensorProduct(A, B)
+    t3 = TensorProduct(C, D)
+
+    d = Density([t2, 0.5], [t3, 0.5])
+    t = Tr(d)
+    assert t.doit() == (0.5*Tr(A*Dagger(A))*Tr(B*Dagger(B)) +
+                        0.5*Tr(C*Dagger(C))*Tr(D*Dagger(D)))
+
+    t = Tr(d, [0])
+    assert t.doit() == (0.5*Tr(A*Dagger(A))*B*Dagger(B) +
+                        0.5*Tr(C*Dagger(C))*D*Dagger(D))
+
+    #Density with mixed states
+    d = Density([t2 + t3, 1.0])
+    t = Tr(d)
+    assert t.doit() == ( 1.0*Tr(A*Dagger(A))*Tr(B*Dagger(B)) +
+                        1.0*Tr(A*Dagger(C))*Tr(B*Dagger(D)) +
+                        1.0*Tr(C*Dagger(A))*Tr(D*Dagger(B)) +
+                        1.0*Tr(C*Dagger(C))*Tr(D*Dagger(D)))
+
+    t = Tr(d, [1] )
+    assert t.doit() == ( 1.0*A*Dagger(A)*Tr(B*Dagger(B)) +
+                        1.0*A*Dagger(C)*Tr(B*Dagger(D)) +
+                        1.0*C*Dagger(A)*Tr(D*Dagger(B)) +
+                        1.0*C*Dagger(C)*Tr(D*Dagger(D)))
+
+
+def test_pr24993():
+    from sympy.matrices.expressions.kronecker import matrix_kronecker_product
+    from sympy.physics.quantum.matrixutils    import matrix_tensor_product
+    X = Matrix([[0, 1], [1, 0]])
+    Xi = ImmutableMatrix(X)
+    assert TensorProduct(Xi, Xi) == TensorProduct(X, X)
+    assert TensorProduct(Xi, Xi) == matrix_tensor_product(X, X)
+    assert TensorProduct(Xi, Xi) == matrix_kronecker_product(X, X)

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_trace.py

@@ -0,0 +1,109 @@
+from sympy.core.containers import Tuple
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import Matrix
+from sympy.physics.quantum.trace import Tr
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+def test_trace_new():
+    a, b, c, d, Y = symbols('a b c d Y')
+    A, B, C, D = symbols('A B C D', commutative=False)
+
+    assert Tr(a + b) == a + b
+    assert Tr(A + B) == Tr(A) + Tr(B)
+
+    #check trace args not implicitly permuted
+    assert Tr(C*D*A*B).args[0].args == (C, D, A, B)
+
+    # check for mul and adds
+    assert Tr((a*b) + ( c*d)) == (a*b) + (c*d)
+    # Tr(scalar*A) = scalar*Tr(A)
+    assert Tr(a*A) == a*Tr(A)
+    assert Tr(a*A*B*b) == a*b*Tr(A*B)
+
+    # since A is symbol and not commutative
+    assert isinstance(Tr(A), Tr)
+
+    #POW
+    assert Tr(pow(a, b)) == a**b
+    assert isinstance(Tr(pow(A, a)), Tr)
+
+    #Matrix
+    M = Matrix([[1, 1], [2, 2]])
+    assert Tr(M) == 3
+
+    ##test indices in different forms
+    #no index
+    t = Tr(A)
+    assert t.args[1] == Tuple()
+
+    #single index
+    t = Tr(A, 0)
+    assert t.args[1] == Tuple(0)
+
+    #index in a list
+    t = Tr(A, [0])
+    assert t.args[1] == Tuple(0)
+
+    t = Tr(A, [0, 1, 2])
+    assert t.args[1] == Tuple(0, 1, 2)
+
+    #index is tuple
+    t = Tr(A, (0))
+    assert t.args[1] == Tuple(0)
+
+    t = Tr(A, (1, 2))
+    assert t.args[1] == Tuple(1, 2)
+
+    #trace indices test
+    t = Tr((A + B), [2])
+    assert t.args[0].args[1] == Tuple(2) and t.args[1].args[1] == Tuple(2)
+
+    t = Tr(a*A, [2, 3])
+    assert t.args[1].args[1] == Tuple(2, 3)
+
+    #class with trace method defined
+    #to simulate numpy objects
+    class Foo:
+        def trace(self):
+            return 1
+    assert Tr(Foo()) == 1
+
+    #argument test
+    # check for value error, when either/both arguments are not provided
+    raises(ValueError, lambda: Tr())
+    raises(ValueError, lambda: Tr(A, 1, 2))
+
+
+def test_trace_doit():
+    a, b, c, d = symbols('a b c d')
+    A, B, C, D = symbols('A B C D', commutative=False)
+
+    #TODO: needed while testing reduced density operations, etc.
+
+
+def test_permute():
+    A, B, C, D, E, F, G = symbols('A B C D E F G', commutative=False)
+    t = Tr(A*B*C*D*E*F*G)
+
+    assert t.permute(0).args[0].args == (A, B, C, D, E, F, G)
+    assert t.permute(2).args[0].args == (F, G, A, B, C, D, E)
+    assert t.permute(4).args[0].args == (D, E, F, G, A, B, C)
+    assert t.permute(6).args[0].args == (B, C, D, E, F, G, A)
+    assert t.permute(8).args[0].args == t.permute(1).args[0].args
+
+    assert t.permute(-1).args[0].args == (B, C, D, E, F, G, A)
+    assert t.permute(-3).args[0].args == (D, E, F, G, A, B, C)
+    assert t.permute(-5).args[0].args == (F, G, A, B, C, D, E)
+    assert t.permute(-8).args[0].args == t.permute(-1).args[0].args
+
+    t = Tr((A + B)*(B*B)*C*D)
+    assert t.permute(2).args[0].args == (C, D, (A + B), (B**2))
+
+    t1 = Tr(A*B)
+    t2 = t1.permute(1)
+    assert id(t1) != id(t2) and t1 == t2
+
+def test_deprecated_core_trace():
+    with warns_deprecated_sympy():
+        from sympy.core.trace import Tr # noqa:F401

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/quantum/tests/test_transforms.py

@@ -0,0 +1,75 @@
+"""Tests of transforms of quantum expressions for Mul and Pow."""
+
+from sympy.core.symbol import symbols
+from sympy.testing.pytest import raises
+
+from sympy.physics.quantum.operator import (
+    Operator, OuterProduct
+)
+from sympy.physics.quantum.state import Ket, Bra
+from sympy.physics.quantum.innerproduct import InnerProduct
+from sympy.physics.quantum.tensorproduct import TensorProduct
+
+
+k1 = Ket('k1')
+k2 = Ket('k2')
+k3 = Ket('k3')
+b1 = Bra('b1')
+b2 = Bra('b2')
+b3 = Bra('b3')
+A = Operator('A')
+B = Operator('B')
+C = Operator('C')
+x, y, z = symbols('x y z')
+
+
+def test_bra_ket():
+    assert b1*k1 == InnerProduct(b1, k1)
+    assert k1*b1 == OuterProduct(k1, b1)
+    # Test priority of inner product
+    assert OuterProduct(k1, b1)*k2 == InnerProduct(b1, k2)*k1
+    assert b1*OuterProduct(k1, b2) == InnerProduct(b1, k1)*b2
+
+
+def test_tensor_product():
+    # We are attempting to be rigourous and raise TypeError when a user tries
+    # to combine bras, kets, and operators in a manner that doesn't make sense.
+    # In particular, we are not trying to interpret regular ``*`` multiplication
+    # as a tensor product.
+    with raises(TypeError):
+        k1*k1
+    with raises(TypeError):
+        b1*b1
+    with raises(TypeError):
+        k1*TensorProduct(k2, k3)
+    with raises(TypeError):
+        b1*TensorProduct(b2, b3)
+    with raises(TypeError):
+        TensorProduct(k2, k3)*k1
+    with raises(TypeError):
+        TensorProduct(b2, b3)*b1
+
+    assert TensorProduct(A, B, C)*TensorProduct(k1, k2, k3) == \
+        TensorProduct(A*k1, B*k2, C*k3)
+    assert TensorProduct(b1, b2, b3)*TensorProduct(A, B, C) == \
+        TensorProduct(b1*A, b2*B, b3*C)
+    assert TensorProduct(b1, b2, b3)*TensorProduct(k1, k2, k3) == \
+        InnerProduct(b1, k1)*InnerProduct(b2, k2)*InnerProduct(b3, k3)
+    assert TensorProduct(b1, b2, b3)*TensorProduct(A, B, C)*TensorProduct(k1, k2, k3) == \
+        TensorProduct(b1*A*k1, b2*B*k2, b3*C*k3)
+
+
+def test_outer_product():
+    assert OuterProduct(k1, b1)*OuterProduct(k2, b2) == \
+        InnerProduct(b1, k2)*OuterProduct(k1, b2)
+
+
+def test_compound():
+    e1 = b1*A*B*k1*b2*k2*b3
+    assert e1 == InnerProduct(b2, k2)*b1*A*B*OuterProduct(k1, b3)
+
+    e2 = TensorProduct(k1, k2)*TensorProduct(b1, b2)
+    assert e2 == TensorProduct(
+        OuterProduct(k1, b1),
+        OuterProduct(k2, b2)
+    )

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/tests/test_clebsch_gordan.py

@@ -0,0 +1,223 @@
+from sympy.core.numbers import (I, pi, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.spherical_harmonics import Ynm
+from sympy.matrices.dense import Matrix
+from sympy.physics.wigner import (clebsch_gordan, wigner_9j, wigner_6j, gaunt,
+        real_gaunt, racah, dot_rot_grad_Ynm, wigner_3j, wigner_d_small, wigner_d)
+from sympy.testing.pytest import raises, skip
+
+# for test cases, refer : https://en.wikipedia.org/wiki/Table_of_Clebsch%E2%80%93Gordan_coefficients
+
+def test_clebsch_gordan_docs():
+    assert clebsch_gordan(Rational(3, 2), S.Half, 2, Rational(3, 2), S.Half, 2) == 1
+    assert clebsch_gordan(Rational(3, 2), S.Half, 1, Rational(3, 2), Rational(-1, 2), 1) == sqrt(3)/2
+    assert clebsch_gordan(Rational(3, 2), S.Half, 1, Rational(-1, 2), S.Half, 0) == -sqrt(2)/2
+
+
+def test_clebsch_gordan():
+    # Argument order: (j_1, j_2, j, m_1, m_2, m)
+
+    h = S.One
+    k = S.Half
+    l = Rational(3, 2)
+    i = Rational(-1, 2)
+    n = Rational(7, 2)
+    p = Rational(5, 2)
+    assert clebsch_gordan(k, k, 1, k, k, 1) == 1
+    assert clebsch_gordan(k, k, 1, k, k, 0) == 0
+    assert clebsch_gordan(k, k, 1, i, i, -1) == 1
+    assert clebsch_gordan(k, k, 1, k, i, 0) == sqrt(2)/2
+    assert clebsch_gordan(k, k, 0, k, i, 0) == sqrt(2)/2
+    assert clebsch_gordan(k, k, 1, i, k, 0) == sqrt(2)/2
+    assert clebsch_gordan(k, k, 0, i, k, 0) == -sqrt(2)/2
+    assert clebsch_gordan(h, k, l, 1, k, l) == 1
+    assert clebsch_gordan(h, k, l, 1, i, k) == 1/sqrt(3)
+    assert clebsch_gordan(h, k, k, 1, i, k) == sqrt(2)/sqrt(3)
+    assert clebsch_gordan(h, k, k, 0, k, k) == -1/sqrt(3)
+    assert clebsch_gordan(h, k, l, 0, k, k) == sqrt(2)/sqrt(3)
+    assert clebsch_gordan(h, h, S(2), 1, 1, S(2)) == 1
+    assert clebsch_gordan(h, h, S(2), 1, 0, 1) == 1/sqrt(2)
+    assert clebsch_gordan(h, h, S(2), 0, 1, 1) == 1/sqrt(2)
+    assert clebsch_gordan(h, h, 1, 1, 0, 1) == 1/sqrt(2)
+    assert clebsch_gordan(h, h, 1, 0, 1, 1) == -1/sqrt(2)
+    assert clebsch_gordan(l, l, S(3), l, l, S(3)) == 1
+    assert clebsch_gordan(l, l, S(2), l, k, S(2)) == 1/sqrt(2)
+    assert clebsch_gordan(l, l, S(3), l, k, S(2)) == 1/sqrt(2)
+    assert clebsch_gordan(S(2), S(2), S(4), S(2), S(2), S(4)) == 1
+    assert clebsch_gordan(S(2), S(2), S(3), S(2), 1, S(3)) == 1/sqrt(2)
+    assert clebsch_gordan(S(2), S(2), S(3), 1, 1, S(2)) == 0
+    assert clebsch_gordan(p, h, n, p, 1, n) == 1
+    assert clebsch_gordan(p, h, p, p, 0, p) == sqrt(5)/sqrt(7)
+    assert clebsch_gordan(p, h, l, k, 1, l) == 1/sqrt(15)
+
+
+def test_clebsch_gordan_numpy():
+    try:
+        import numpy as np
+    except ImportError:
+        skip("numpy not installed")
+    assert clebsch_gordan(*np.zeros(6).astype(np.int64)) == 1
+    assert wigner_3j(2, np.float64(6.0), 4.0, 0, 0, 0) == sqrt(715)/143
+    assert wigner_3j(0, 0.5, 0.5, 0, 0.5, -0.5) == sqrt(2)/2
+    raises(ValueError, lambda: wigner_3j(2.1, 6, 4, 0, 0, 0))
+
+
+def test_wigner():
+    try:
+        import numpy as np
+    except ImportError:
+        skip("numpy not installed")
+    def tn(a, b):
+        return (a - b).n(64) < S('1e-64')
+    assert tn(wigner_9j(1, 1, 1, 1, 1, 1, 1, 1, 0, prec=64), Rational(1, 18))
+    assert wigner_9j(3, 3, 2, 3, 3, 2, 3, 3, 2) == 3221*sqrt(
+        70)/(246960*sqrt(105)) - 365/(3528*sqrt(70)*sqrt(105))
+    assert wigner_6j(5, 5, 5, 5, 5, 5) == Rational(1, 52)
+    assert tn(wigner_6j(8, 8, 8, 8, 8, 8, prec=64), Rational(-12219, 965770))
+    assert wigner_6j(1, 1, 1, 1.0, np.float64(1.0), 1) == Rational(1, 6)
+    assert wigner_6j(3.0, np.float32(3), 3.0, 3, 3, 3) == Rational(-1, 14)
+    # regression test for #8747
+    half = S.Half
+    assert wigner_9j(0, 0, 0, 0, half, half, 0, half, half) == half
+    assert (wigner_9j(3, 5, 4,
+                      7 * half, 5 * half, 4,
+                      9 * half, 9 * half, 0)
+            == -sqrt(Rational(361, 205821000)))
+    assert (wigner_9j(1, 4, 3,
+                      5 * half, 4, 5 * half,
+                      5 * half, 2, 7 * half)
+            == -sqrt(Rational(3971, 373403520)))
+    assert (wigner_9j(4, 9 * half, 5 * half,
+                      2, 4, 4,
+                      5, 7 * half, 7 * half)
+            == -sqrt(Rational(3481, 5042614500)))
+    assert (wigner_9j(5, 5, 5.0,
+                      np.float64(5.0), 5, 5,
+                      5, 5, 5)
+            == 0)
+    assert (wigner_9j(1.0, 2.0, 3.0,
+                      3, 2, 1,
+                      2, 1, 3)
+            == -4*sqrt(70)/11025)
+
+
+def test_gaunt():
+    def tn(a, b):
+        return (a - b).n(64) < S('1e-64')
+    assert gaunt(1, 0, 1, 1, 0, -1) == -1/(2*sqrt(pi))
+    assert isinstance(gaunt(1, 1, 0, -1, 1, 0).args[0], Rational)
+    assert isinstance(gaunt(0, 1, 1, 0, -1, 1).args[0], Rational)
+
+    assert tn(gaunt(
+        10, 10, 12, 9, 3, -12, prec=64), (Rational(-98, 62031)) * sqrt(6279)/sqrt(pi))
+    def gaunt_ref(l1, l2, l3, m1, m2, m3):
+        return (
+            sqrt((2 * l1 + 1) * (2 * l2 + 1) * (2 * l3 + 1) / (4 * pi)) *
+            wigner_3j(l1, l2, l3, 0, 0, 0) *
+            wigner_3j(l1, l2, l3, m1, m2, m3)
+        )
+    threshold = 1e-10
+    l_max = 3
+    l3_max = 24
+    for l1 in range(l_max + 1):
+        for l2 in range(l_max + 1):
+            for l3 in range(l3_max + 1):
+                for m1 in range(-l1, l1 + 1):
+                    for m2 in range(-l2, l2 + 1):
+                        for m3 in range(-l3, l3 + 1):
+                            args = l1, l2, l3, m1, m2, m3
+                            g  = gaunt(*args)
+                            g0 = gaunt_ref(*args)
+                            assert abs(g - g0) < threshold
+                            if m1 + m2 + m3 != 0:
+                                assert abs(g) < threshold
+                            if (l1 + l2 + l3) % 2:
+                                assert abs(g) < threshold
+    assert gaunt(1, 1, 0, 0, 2, -2) is S.Zero
+
+
+def test_realgaunt():
+    # All non-zero values corresponding to l values from 0 to 2
+    for l in range(3):
+        for m in range(-l, l+1):
+            assert real_gaunt(0, l, l, 0, m, m) == 1/(2*sqrt(pi))
+    assert real_gaunt(1, 1, 2, 0, 0, 0) == sqrt(5)/(5*sqrt(pi))
+    assert real_gaunt(1, 1, 2, 1, 1, 0) == -sqrt(5)/(10*sqrt(pi))
+    assert real_gaunt(2, 2, 2, 0, 0, 0) == sqrt(5)/(7*sqrt(pi))
+    assert real_gaunt(2, 2, 2, 0, 2, 2) == -sqrt(5)/(7*sqrt(pi))
+    assert real_gaunt(2, 2, 2, -2, -2, 0) == -sqrt(5)/(7*sqrt(pi))
+    assert real_gaunt(1, 1, 2, -1, 0, -1) == sqrt(15)/(10*sqrt(pi))
+    assert real_gaunt(1, 1, 2, 0, 1, 1) == sqrt(15)/(10*sqrt(pi))
+    assert real_gaunt(1, 1, 2, 1, 1, 2) == sqrt(15)/(10*sqrt(pi))
+    assert real_gaunt(1, 1, 2, -1, 1, -2) == sqrt(15)/(10*sqrt(pi))
+    assert real_gaunt(1, 1, 2, -1, -1, 2) == -sqrt(15)/(10*sqrt(pi))
+    assert real_gaunt(2, 2, 2, 0, 1, 1) == sqrt(5)/(14*sqrt(pi))
+    assert real_gaunt(2, 2, 2, 1, 1, 2) == sqrt(15)/(14*sqrt(pi))
+    assert real_gaunt(2, 2, 2, -1, -1, 2) == -sqrt(15)/(14*sqrt(pi))
+
+    assert real_gaunt(-2, -2, -2, -2, -2, 0) is S.Zero  # m test
+    assert real_gaunt(-2, 1, 0, 1, 1, 1) is S.Zero  # l test
+    assert real_gaunt(-2, -1, -2, -1, -1, 0) is S.Zero  # m and l test
+    assert real_gaunt(-2, -2, -2, -2, -2, -2) is S.Zero  # m and k test
+    assert real_gaunt(-2, -1, -2, -1, -1, -1) is S.Zero  # m, l and k test
+
+    x = symbols('x', integer=True)
+    v = [0]*6
+    for i in range(len(v)):
+        v[i] = x  # non literal ints fail
+        raises(ValueError, lambda: real_gaunt(*v))
+        v[i] = 0
+
+
+def test_racah():
+    assert racah(3,3,3,3,3,3) == Rational(-1,14)
+    assert racah(2,2,2,2,2,2) == Rational(-3,70)
+    assert racah(7,8,7,1,7,7, prec=4).is_Float
+    assert racah(5.5,7.5,9.5,6.5,8,9) == -719*sqrt(598)/1158924
+    assert abs(racah(5.5,7.5,9.5,6.5,8,9, prec=4) - (-0.01517)) < S('1e-4')
+
+
+def test_dot_rota_grad_SH():
+    theta, phi = symbols("theta phi")
+    assert dot_rot_grad_Ynm(1, 1, 1, 1, 1, 0) !=  \
+        sqrt(30)*Ynm(2, 2, 1, 0)/(10*sqrt(pi))
+    assert dot_rot_grad_Ynm(1, 1, 1, 1, 1, 0).doit() ==  \
+        sqrt(30)*Ynm(2, 2, 1, 0)/(10*sqrt(pi))
+    assert dot_rot_grad_Ynm(1, 5, 1, 1, 1, 2) !=  \
+        0
+    assert dot_rot_grad_Ynm(1, 5, 1, 1, 1, 2).doit() ==  \
+        0
+    assert dot_rot_grad_Ynm(3, 3, 3, 3, theta, phi).doit() ==  \
+        15*sqrt(3003)*Ynm(6, 6, theta, phi)/(143*sqrt(pi))
+    assert dot_rot_grad_Ynm(3, 3, 1, 1, theta, phi).doit() ==  \
+        sqrt(3)*Ynm(4, 4, theta, phi)/sqrt(pi)
+    assert dot_rot_grad_Ynm(3, 2, 2, 0, theta, phi).doit() ==  \
+        3*sqrt(55)*Ynm(5, 2, theta, phi)/(11*sqrt(pi))
+    assert dot_rot_grad_Ynm(3, 2, 3, 2, theta, phi).doit().expand() ==  \
+        -sqrt(70)*Ynm(4, 4, theta, phi)/(11*sqrt(pi)) + \
+        45*sqrt(182)*Ynm(6, 4, theta, phi)/(143*sqrt(pi))
+
+
+def test_wigner_d():
+    half = S(1)/2
+    assert wigner_d_small(half, 0) == Matrix([[1, 0], [0, 1]])
+    assert wigner_d_small(half, pi/2) == Matrix([[1, 1], [-1, 1]])/sqrt(2)
+    assert wigner_d_small(half, pi) == Matrix([[0, 1], [-1, 0]])
+
+    alpha, beta, gamma = symbols("alpha, beta, gamma", real=True)
+    D = wigner_d(half, alpha, beta, gamma)
+    assert D[0, 0] == exp(I*alpha/2)*exp(I*gamma/2)*cos(beta/2)
+    assert D[0, 1] == exp(I*alpha/2)*exp(-I*gamma/2)*sin(beta/2)
+    assert D[1, 0] == -exp(-I*alpha/2)*exp(I*gamma/2)*sin(beta/2)
+    assert D[1, 1] == exp(-I*alpha/2)*exp(-I*gamma/2)*cos(beta/2)
+
+    # Test Y_{n mi}(g*x)=\sum_{mj}D^n_{mi mj}*Y_{n mj}(x)
+    theta, phi = symbols("theta phi", real=True)
+    v = Matrix([Ynm(1, mj, theta, phi) for mj in range(1, -2, -1)])
+    w = wigner_d(1, -pi/2, pi/2, -pi/2)@v.subs({theta: pi/4, phi: pi})
+    w_ = v.subs({theta: pi/2, phi: pi/4})
+    assert w.expand(func=True).as_real_imag() == w_.expand(func=True).as_real_imag()

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/tests/test_hydrogen.py

@@ -0,0 +1,126 @@
+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
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import integrate
+from sympy.simplify.simplify import simplify
+from sympy.physics.hydrogen import R_nl, E_nl, E_nl_dirac, Psi_nlm
+from sympy.testing.pytest import raises
+
+n, r, Z = symbols('n r Z')
+
+
+def feq(a, b, max_relative_error=1e-12, max_absolute_error=1e-12):
+    a = float(a)
+    b = float(b)
+    # if the numbers are close enough (absolutely), then they are equal
+    if abs(a - b) < max_absolute_error:
+        return True
+    # if not, they can still be equal if their relative error is small
+    if abs(b) > abs(a):
+        relative_error = abs((a - b)/b)
+    else:
+        relative_error = abs((a - b)/a)
+    return relative_error <= max_relative_error
+
+
+def test_wavefunction():
+    a = 1/Z
+    R = {
+        (1, 0): 2*sqrt(1/a**3) * exp(-r/a),
+        (2, 0): sqrt(1/(2*a**3)) * exp(-r/(2*a)) * (1 - r/(2*a)),
+        (2, 1): S.Half * sqrt(1/(6*a**3)) * exp(-r/(2*a)) * r/a,
+        (3, 0): Rational(2, 3) * sqrt(1/(3*a**3)) * exp(-r/(3*a)) *
+        (1 - 2*r/(3*a) + Rational(2, 27) * (r/a)**2),
+        (3, 1): Rational(4, 27) * sqrt(2/(3*a**3)) * exp(-r/(3*a)) *
+        (1 - r/(6*a)) * r/a,
+        (3, 2): Rational(2, 81) * sqrt(2/(15*a**3)) * exp(-r/(3*a)) * (r/a)**2,
+        (4, 0): Rational(1, 4) * sqrt(1/a**3) * exp(-r/(4*a)) *
+        (1 - 3*r/(4*a) + Rational(1, 8) * (r/a)**2 - Rational(1, 192) * (r/a)**3),
+        (4, 1): Rational(1, 16) * sqrt(5/(3*a**3)) * exp(-r/(4*a)) *
+        (1 - r/(4*a) + Rational(1, 80) * (r/a)**2) * (r/a),
+        (4, 2): Rational(1, 64) * sqrt(1/(5*a**3)) * exp(-r/(4*a)) *
+        (1 - r/(12*a)) * (r/a)**2,
+        (4, 3): Rational(1, 768) * sqrt(1/(35*a**3)) * exp(-r/(4*a)) * (r/a)**3,
+    }
+    for n, l in R:
+        assert simplify(R_nl(n, l, r, Z) - R[(n, l)]) == 0
+
+
+def test_norm():
+    # Maximum "n" which is tested:
+    n_max = 2  # it works, but is slow, for n_max > 2
+    for n in range(n_max + 1):
+        for l in range(n):
+            assert integrate(R_nl(n, l, r)**2 * r**2, (r, 0, oo)) == 1
+
+def test_psi_nlm():
+    r=S('r')
+    phi=S('phi')
+    theta=S('theta')
+    assert (Psi_nlm(1, 0, 0, r, phi, theta) == exp(-r) / sqrt(pi))
+    assert (Psi_nlm(2, 1, -1, r, phi, theta)) == S.Half * exp(-r / (2)) * r \
+        * (sin(theta) * exp(-I * phi) / (4 * sqrt(pi)))
+    assert (Psi_nlm(3, 2, 1, r, phi, theta, 2) == -sqrt(2) * sin(theta) \
+         * exp(I * phi) * cos(theta) / (4 * sqrt(pi)) * S(2) / 81 \
+        * sqrt(2 * 2 ** 3) * exp(-2 * r / (3)) * (r * 2) ** 2)
+
+def test_hydrogen_energies():
+    assert E_nl(n, Z) == -Z**2/(2*n**2)
+    assert E_nl(n) == -1/(2*n**2)
+
+    assert E_nl(1, 47) == -S(47)**2/(2*1**2)
+    assert E_nl(2, 47) == -S(47)**2/(2*2**2)
+
+    assert E_nl(1) == -S.One/(2*1**2)
+    assert E_nl(2) == -S.One/(2*2**2)
+    assert E_nl(3) == -S.One/(2*3**2)
+    assert E_nl(4) == -S.One/(2*4**2)
+    assert E_nl(100) == -S.One/(2*100**2)
+
+    raises(ValueError, lambda: E_nl(0))
+
+
+def test_hydrogen_energies_relat():
+    # First test exact formulas for small "c" so that we get nice expressions:
+    assert E_nl_dirac(2, 0, Z=1, c=1) == 1/sqrt(2) - 1
+    assert simplify(E_nl_dirac(2, 0, Z=1, c=2) - ( (8*sqrt(3) + 16)
+                / sqrt(16*sqrt(3) + 32) - 4)) == 0
+    assert simplify(E_nl_dirac(2, 0, Z=1, c=3) - ( (54*sqrt(2) + 81)
+                / sqrt(108*sqrt(2) + 162) - 9)) == 0
+
+    # Now test for almost the correct speed of light, without floating point
+    # numbers:
+    assert simplify(E_nl_dirac(2, 0, Z=1, c=137) - ( (352275361 + 10285412 *
+        sqrt(1173)) / sqrt(704550722 + 20570824 * sqrt(1173)) - 18769)) == 0
+    assert simplify(E_nl_dirac(2, 0, Z=82, c=137) - ( (352275361 + 2571353 *
+        sqrt(12045)) / sqrt(704550722 + 5142706*sqrt(12045)) - 18769)) == 0
+
+    # Test using exact speed of light, and compare against the nonrelativistic
+    # energies:
+    for n in range(1, 5):
+        for l in range(n):
+            assert feq(E_nl_dirac(n, l), E_nl(n), 1e-5, 1e-5)
+            if l > 0:
+                assert feq(E_nl_dirac(n, l, False), E_nl(n), 1e-5, 1e-5)
+
+    Z = 2
+    for n in range(1, 5):
+        for l in range(n):
+            assert feq(E_nl_dirac(n, l, Z=Z), E_nl(n, Z), 1e-4, 1e-4)
+            if l > 0:
+                assert feq(E_nl_dirac(n, l, False, Z), E_nl(n, Z), 1e-4, 1e-4)
+
+    Z = 3
+    for n in range(1, 5):
+        for l in range(n):
+            assert feq(E_nl_dirac(n, l, Z=Z), E_nl(n, Z), 1e-3, 1e-3)
+            if l > 0:
+                assert feq(E_nl_dirac(n, l, False, Z), E_nl(n, Z), 1e-3, 1e-3)
+
+    # Test the exceptions:
+    raises(ValueError, lambda: E_nl_dirac(0, 0))
+    raises(ValueError, lambda: E_nl_dirac(1, -1))
+    raises(ValueError, lambda: E_nl_dirac(1, 0, False))

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/tests/test_paulialgebra.py

@@ -0,0 +1,57 @@
+from sympy.core.numbers import I
+from sympy.core.symbol import symbols
+from sympy.physics.paulialgebra import Pauli
+from sympy.testing.pytest import XFAIL
+from sympy.physics.quantum import TensorProduct
+
+sigma1 = Pauli(1)
+sigma2 = Pauli(2)
+sigma3 = Pauli(3)
+
+tau1 = symbols("tau1", commutative = False)
+
+
+def test_Pauli():
+
+    assert sigma1 == sigma1
+    assert sigma1 != sigma2
+
+    assert sigma1*sigma2 == I*sigma3
+    assert sigma3*sigma1 == I*sigma2
+    assert sigma2*sigma3 == I*sigma1
+
+    assert sigma1*sigma1 == 1
+    assert sigma2*sigma2 == 1
+    assert sigma3*sigma3 == 1
+
+    assert sigma1**0 == 1
+    assert sigma1**1 == sigma1
+    assert sigma1**2 == 1
+    assert sigma1**3 == sigma1
+    assert sigma1**4 == 1
+
+    assert sigma3**2 == 1
+
+    assert sigma1*2*sigma1 == 2
+
+
+def test_evaluate_pauli_product():
+    from sympy.physics.paulialgebra import evaluate_pauli_product
+
+    assert evaluate_pauli_product(I*sigma2*sigma3) == -sigma1
+
+    # Check issue 6471
+    assert evaluate_pauli_product(-I*4*sigma1*sigma2) == 4*sigma3
+
+    assert evaluate_pauli_product(
+        1 + I*sigma1*sigma2*sigma1*sigma2 + \
+        I*sigma1*sigma2*tau1*sigma1*sigma3 + \
+        ((tau1**2).subs(tau1, I*sigma1)) + \
+        sigma3*((tau1**2).subs(tau1, I*sigma1)) + \
+        TensorProduct(I*sigma1*sigma2*sigma1*sigma2, 1)
+    ) == 1 -I + I*sigma3*tau1*sigma2 - 1 - sigma3 - I*TensorProduct(1,1)
+
+
+@XFAIL
+def test_Pauli_should_work():
+    assert sigma1*sigma3*sigma1 == -sigma3

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/tests/test_physics_matrices.py

@@ -0,0 +1,84 @@
+from sympy.physics.matrices import msigma, mgamma, minkowski_tensor, pat_matrix, mdft
+from sympy.core.numbers import (I, Rational)
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import (Matrix, eye, zeros)
+from sympy.testing.pytest import warns_deprecated_sympy
+
+
+def test_parallel_axis_theorem():
+    # This tests the parallel axis theorem matrix by comparing to test
+    # matrices.
+
+    # First case, 1 in all directions.
+    mat1 = Matrix(((2, -1, -1), (-1, 2, -1), (-1, -1, 2)))
+    assert pat_matrix(1, 1, 1, 1) == mat1
+    assert pat_matrix(2, 1, 1, 1) == 2*mat1
+
+    # Second case, 1 in x, 0 in all others
+    mat2 = Matrix(((0, 0, 0), (0, 1, 0), (0, 0, 1)))
+    assert pat_matrix(1, 1, 0, 0) == mat2
+    assert pat_matrix(2, 1, 0, 0) == 2*mat2
+
+    # Third case, 1 in y, 0 in all others
+    mat3 = Matrix(((1, 0, 0), (0, 0, 0), (0, 0, 1)))
+    assert pat_matrix(1, 0, 1, 0) == mat3
+    assert pat_matrix(2, 0, 1, 0) == 2*mat3
+
+    # Fourth case, 1 in z, 0 in all others
+    mat4 = Matrix(((1, 0, 0), (0, 1, 0), (0, 0, 0)))
+    assert pat_matrix(1, 0, 0, 1) == mat4
+    assert pat_matrix(2, 0, 0, 1) == 2*mat4
+
+
+def test_Pauli():
+    #this and the following test are testing both Pauli and Dirac matrices
+    #and also that the general Matrix class works correctly in a real world
+    #situation
+    sigma1 = msigma(1)
+    sigma2 = msigma(2)
+    sigma3 = msigma(3)
+
+    assert sigma1 == sigma1
+    assert sigma1 != sigma2
+
+    # sigma*I -> I*sigma    (see #354)
+    assert sigma1*sigma2 == sigma3*I
+    assert sigma3*sigma1 == sigma2*I
+    assert sigma2*sigma3 == sigma1*I
+
+    assert sigma1*sigma1 == eye(2)
+    assert sigma2*sigma2 == eye(2)
+    assert sigma3*sigma3 == eye(2)
+
+    assert sigma1*2*sigma1 == 2*eye(2)
+    assert sigma1*sigma3*sigma1 == -sigma3
+
+
+def test_Dirac():
+    gamma0 = mgamma(0)
+    gamma1 = mgamma(1)
+    gamma2 = mgamma(2)
+    gamma3 = mgamma(3)
+    gamma5 = mgamma(5)
+
+    # gamma*I -> I*gamma    (see #354)
+    assert gamma5 == gamma0 * gamma1 * gamma2 * gamma3 * I
+    assert gamma1 * gamma2 + gamma2 * gamma1 == zeros(4)
+    assert gamma0 * gamma0 == eye(4) * minkowski_tensor[0, 0]
+    assert gamma2 * gamma2 != eye(4) * minkowski_tensor[0, 0]
+    assert gamma2 * gamma2 == eye(4) * minkowski_tensor[2, 2]
+
+    assert mgamma(5, True) == \
+        mgamma(0, True)*mgamma(1, True)*mgamma(2, True)*mgamma(3, True)*I
+
+def test_mdft():
+    with warns_deprecated_sympy():
+        assert mdft(1) == Matrix([[1]])
+    with warns_deprecated_sympy():
+        assert mdft(2) == 1/sqrt(2)*Matrix([[1,1],[1,-1]])
+    with warns_deprecated_sympy():
+        assert mdft(4) == Matrix([[S.Half,  S.Half,  S.Half, S.Half],
+                                  [S.Half, -I/2, Rational(-1,2),  I/2],
+                                  [S.Half, Rational(-1,2),  S.Half, Rational(-1,2)],
+                                  [S.Half,  I/2, Rational(-1,2), -I/2]])

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/tests/test_pring.py

@@ -0,0 +1,41 @@
+from sympy.physics.pring import wavefunction, energy
+from sympy.core.numbers import (I, pi)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.integrals.integrals import integrate
+from sympy.simplify.simplify import simplify
+from sympy.abc import m, x, r
+from sympy.physics.quantum.constants import hbar
+
+
+def test_wavefunction():
+    Psi = {
+        0: (1/sqrt(2 * pi)),
+        1: (1/sqrt(2 * pi)) * exp(I * x),
+        2: (1/sqrt(2 * pi)) * exp(2 * I * x),
+        3: (1/sqrt(2 * pi)) * exp(3 * I * x)
+    }
+    for n in Psi:
+        assert simplify(wavefunction(n, x) - Psi[n]) == 0
+
+
+def test_norm(n=1):
+    # Maximum "n" which is tested:
+    for i in range(n + 1):
+        assert integrate(
+            wavefunction(i, x) * wavefunction(-i, x), (x, 0, 2 * pi)) == 1
+
+
+def test_orthogonality(n=1):
+    # Maximum "n" which is tested:
+    for i in range(n + 1):
+        for j in range(i+1, n+1):
+            assert integrate(
+                wavefunction(i, x) * wavefunction(j, x), (x, 0, 2 * pi)) == 0
+
+
+def test_energy(n=1):
+    # Maximum "n" which is tested:
+    for i in range(n+1):
+        assert simplify(
+            energy(i, m, r) - ((i**2 * hbar**2) / (2 * m * r**2))) == 0

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/tests/test_qho_1d.py

@@ -0,0 +1,50 @@
+from sympy.core.numbers import (Rational, oo, pi)
+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.integrals.integrals import integrate
+from sympy.simplify.simplify import simplify
+from sympy.abc import omega, m, x
+from sympy.physics.qho_1d import psi_n, E_n, coherent_state
+from sympy.physics.quantum.constants import hbar
+
+nu = m * omega / hbar
+
+
+def test_wavefunction():
+    Psi = {
+        0: (nu/pi)**Rational(1, 4) * exp(-nu * x**2 /2),
+        1: (nu/pi)**Rational(1, 4) * sqrt(2*nu) * x * exp(-nu * x**2 /2),
+        2: (nu/pi)**Rational(1, 4) * (2 * nu * x**2 - 1)/sqrt(2) * exp(-nu * x**2 /2),
+        3: (nu/pi)**Rational(1, 4) * sqrt(nu/3) * (2 * nu * x**3 - 3 * x) * exp(-nu * x**2 /2)
+    }
+    for n in Psi:
+        assert simplify(psi_n(n, x, m, omega) - Psi[n]) == 0
+
+
+def test_norm(n=1):
+    # Maximum "n" which is tested:
+    for i in range(n + 1):
+        assert integrate(psi_n(i, x, 1, 1)**2, (x, -oo, oo)) == 1
+
+
+def test_orthogonality(n=1):
+    # Maximum "n" which is tested:
+    for i in range(n + 1):
+        for j in range(i + 1, n + 1):
+            assert integrate(
+                psi_n(i, x, 1, 1)*psi_n(j, x, 1, 1), (x, -oo, oo)) == 0
+
+
+def test_energies(n=1):
+    # Maximum "n" which is tested:
+    for i in range(n + 1):
+        assert E_n(i, omega) == hbar * omega * (i + S.Half)
+
+def test_coherent_state(n=10):
+    # Maximum "n" which is tested:
+    # test whether coherent state is the eigenstate of annihilation operator
+    alpha = Symbol("alpha")
+    for i in range(n + 1):
+        assert simplify(sqrt(n + 1) * coherent_state(n + 1, alpha)) == simplify(alpha * coherent_state(n, alpha))

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/tests/test_secondquant.py

@@ -0,0 +1,1301 @@
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.exponential import exp
+from sympy.physics.secondquant import (
+    Dagger, Bd, VarBosonicBasis, BBra, B, BKet, FixedBosonicBasis,
+    matrix_rep, apply_operators, InnerProduct, Commutator, KroneckerDelta,
+    AnnihilateBoson, CreateBoson, BosonicOperator,
+    F, Fd, FKet, BosonState, CreateFermion, AnnihilateFermion,
+    evaluate_deltas, AntiSymmetricTensor, contraction, NO, wicks,
+    PermutationOperator, simplify_index_permutations,
+    _sort_anticommuting_fermions, _get_ordered_dummies,
+    substitute_dummies, FockStateBosonKet,
+    ContractionAppliesOnlyToFermions
+)
+
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Function, expand)
+from sympy.core.numbers import (I, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.printing.repr import srepr
+from sympy.simplify.simplify import simplify
+
+from sympy.testing.pytest import slow, raises
+from sympy.printing.latex import latex
+
+
+def test_PermutationOperator():
+    p, q, r, s = symbols('p,q,r,s')
+    f, g, h, i = map(Function, 'fghi')
+    P = PermutationOperator
+    assert P(p, q).get_permuted(f(p)*g(q)) == -f(q)*g(p)
+    assert P(p, q).get_permuted(f(p, q)) == -f(q, p)
+    assert P(p, q).get_permuted(f(p)) == f(p)
+    expr = (f(p)*g(q)*h(r)*i(s)
+        - f(q)*g(p)*h(r)*i(s)
+        - f(p)*g(q)*h(s)*i(r)
+        + f(q)*g(p)*h(s)*i(r))
+    perms = [P(p, q), P(r, s)]
+    assert (simplify_index_permutations(expr, perms) ==
+        P(p, q)*P(r, s)*f(p)*g(q)*h(r)*i(s))
+    assert latex(P(p, q)) == 'P(pq)'
+
+    p1, p2 = symbols('p1,p2')
+    assert latex(P(p1,p2) == 'P(p_{1}p_{2})')
+
+def test_index_permutations_with_dummies():
+    a, b, c, d = symbols('a b c d')
+    p, q, r, s = symbols('p q r s', cls=Dummy)
+    f, g = map(Function, 'fg')
+    P = PermutationOperator
+
+    # No dummy substitution necessary
+    expr = f(a, b, p, q) - f(b, a, p, q)
+    assert simplify_index_permutations(
+        expr, [P(a, b)]) == P(a, b)*f(a, b, p, q)
+
+    # Cases where dummy substitution is needed
+    expected = P(a, b)*substitute_dummies(f(a, b, p, q))
+
+    expr = f(a, b, p, q) - f(b, a, q, p)
+    result = simplify_index_permutations(expr, [P(a, b)])
+    assert expected == substitute_dummies(result)
+
+    expr = f(a, b, q, p) - f(b, a, p, q)
+    result = simplify_index_permutations(expr, [P(a, b)])
+    assert expected == substitute_dummies(result)
+
+    # A case where nothing can be done
+    expr = f(a, b, q, p) - g(b, a, p, q)
+    result = simplify_index_permutations(expr, [P(a, b)])
+    assert expr == result
+
+
+def test_dagger():
+    i, j, n, m = symbols('i,j,n,m')
+    assert Dagger(1) == 1
+    assert Dagger(1.0) == 1.0
+    assert Dagger(2*I) == -2*I
+    assert Dagger(S.Half*I/3.0) == I*Rational(-1, 2)/3.0
+    assert Dagger(BKet([n])) == BBra([n])
+    assert Dagger(B(0)) == Bd(0)
+    assert Dagger(Bd(0)) == B(0)
+    assert Dagger(B(n)) == Bd(n)
+    assert Dagger(Bd(n)) == B(n)
+    assert Dagger(B(0) + B(1)) == Bd(0) + Bd(1)
+    assert Dagger(n*m) == Dagger(n)*Dagger(m)  # n, m commute
+    assert Dagger(B(n)*B(m)) == Bd(m)*Bd(n)
+    assert Dagger(B(n)**10) == Dagger(B(n))**10
+    assert Dagger('a') == Dagger(Symbol('a'))
+    assert Dagger(Dagger('a')) == Symbol('a')
+    assert Dagger(exp(2 * I)) == exp(-2 * I)
+    assert Dagger(i) == conjugate(i)
+
+
+def test_operator():
+    i, j = symbols('i,j')
+    o = BosonicOperator(i)
+    assert o.state == i
+    assert o.is_symbolic
+    o = BosonicOperator(1)
+    assert o.state == 1
+    assert not o.is_symbolic
+
+
+def test_create():
+    i, j, n, m, p1 = symbols('i,j,n,m,p1')
+    o = Bd(i)
+    assert latex(o) == "{b^\\dagger_{i}}"
+    assert latex(Bd(p1)) == "{b^\\dagger_{p_{1}}}"
+    assert isinstance(o, CreateBoson)
+    o = o.subs(i, j)
+    assert o.atoms(Symbol) == {j}
+    o = Bd(0)
+    assert o.apply_operator(BKet([n])) == sqrt(n + 1)*BKet([n + 1])
+    o = Bd(n)
+    assert o.apply_operator(BKet([n])) == o*BKet([n])
+
+
+def test_annihilate():
+    i, j, n, m, p1 = symbols('i,j,n,m,p1')
+    o = B(i)
+    assert latex(o) == "b_{i}"
+    assert latex(B(p1)) == "b_{p_{1}}"
+    assert isinstance(o, AnnihilateBoson)
+    o = o.subs(i, j)
+    assert o.atoms(Symbol) == {j}
+    o = B(0)
+    assert o.apply_operator(BKet([n])) == sqrt(n)*BKet([n - 1])
+    o = B(n)
+    assert o.apply_operator(BKet([n])) == o*BKet([n])
+
+
+def test_basic_state():
+    i, j, n, m = symbols('i,j,n,m')
+    s = BosonState([0, 1, 2, 3, 4])
+    assert len(s) == 5
+    assert s.args[0] == tuple(range(5))
+    assert s.up(0) == BosonState([1, 1, 2, 3, 4])
+    assert s.down(4) == BosonState([0, 1, 2, 3, 3])
+    for i in range(5):
+        assert s.up(i).down(i) == s
+    assert s.down(0) == 0
+    for i in range(5):
+        assert s[i] == i
+    s = BosonState([n, m])
+    assert s.down(0) == BosonState([n - 1, m])
+    assert s.up(0) == BosonState([n + 1, m])
+
+
+def test_basic_apply():
+    n = symbols("n")
+    e = B(0)*BKet([n])
+    assert apply_operators(e) == sqrt(n)*BKet([n - 1])
+    e = Bd(0)*BKet([n])
+    assert apply_operators(e) == sqrt(n + 1)*BKet([n + 1])
+
+
+def test_complex_apply():
+    n, m = symbols("n,m")
+    o = Bd(0)*B(0)*Bd(1)*B(0)
+    e = apply_operators(o*BKet([n, m]))
+    answer = sqrt(n)*sqrt(m + 1)*(-1 + n)*BKet([-1 + n, 1 + m])
+    assert expand(e) == expand(answer)
+
+
+def test_number_operator():
+    n = symbols("n")
+    o = Bd(0)*B(0)
+    e = apply_operators(o*BKet([n]))
+    assert e == n*BKet([n])
+
+
+def test_inner_product():
+    i, j, k, l = symbols('i,j,k,l')
+    s1 = BBra([0])
+    s2 = BKet([1])
+    assert InnerProduct(s1, Dagger(s1)) == 1
+    assert InnerProduct(s1, s2) == 0
+    s1 = BBra([i, j])
+    s2 = BKet([k, l])
+    r = InnerProduct(s1, s2)
+    assert r == KroneckerDelta(i, k)*KroneckerDelta(j, l)
+
+
+def test_symbolic_matrix_elements():
+    n, m = symbols('n,m')
+    s1 = BBra([n])
+    s2 = BKet([m])
+    o = B(0)
+    e = apply_operators(s1*o*s2)
+    assert e == sqrt(m)*KroneckerDelta(n, m - 1)
+
+
+def test_matrix_elements():
+    b = VarBosonicBasis(5)
+    o = B(0)
+    m = matrix_rep(o, b)
+    for i in range(4):
+        assert m[i, i + 1] == sqrt(i + 1)
+    o = Bd(0)
+    m = matrix_rep(o, b)
+    for i in range(4):
+        assert m[i + 1, i] == sqrt(i + 1)
+
+
+def test_fixed_bosonic_basis():
+    b = FixedBosonicBasis(2, 2)
+    # assert b == [FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]
+    state = b.state(1)
+    assert state == FockStateBosonKet((1, 1))
+    assert b.index(state) == 1
+    assert b.state(1) == b[1]
+    assert len(b) == 3
+    assert str(b) == '[FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]'
+    assert repr(b) == '[FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]'
+    assert srepr(b) == '[FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]'
+
+
+@slow
+def test_sho():
+    n, m = symbols('n,m')
+    h_n = Bd(n)*B(n)*(n + S.Half)
+    H = Sum(h_n, (n, 0, 5))
+    o = H.doit(deep=False)
+    b = FixedBosonicBasis(2, 6)
+    m = matrix_rep(o, b)
+    # We need to double check these energy values to make sure that they
+    # are correct and have the proper degeneracies!
+    diag = [1, 2, 3, 3, 4, 5, 4, 5, 6, 7, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10, 11]
+    for i in range(len(diag)):
+        assert diag[i] == m[i, i]
+
+
+def test_commutation():
+    n, m = symbols("n,m", above_fermi=True)
+    c = Commutator(B(0), Bd(0))
+    assert c == 1
+    c = Commutator(Bd(0), B(0))
+    assert c == -1
+    c = Commutator(B(n), Bd(0))
+    assert c == KroneckerDelta(n, 0)
+    c = Commutator(B(0), B(0))
+    assert c == 0
+    c = Commutator(B(0), Bd(0))
+    e = simplify(apply_operators(c*BKet([n])))
+    assert e == BKet([n])
+    c = Commutator(B(0), B(1))
+    e = simplify(apply_operators(c*BKet([n, m])))
+    assert e == 0
+
+    c = Commutator(F(m), Fd(m))
+    assert c == +1 - 2*NO(Fd(m)*F(m))
+    c = Commutator(Fd(m), F(m))
+    assert c.expand() == -1 + 2*NO(Fd(m)*F(m))
+
+    C = Commutator
+    X, Y, Z = symbols('X,Y,Z', commutative=False)
+    assert C(C(X, Y), Z) != 0
+    assert C(C(X, Z), Y) != 0
+    assert C(Y, C(X, Z)) != 0
+
+    i, j, k, l = symbols('i,j,k,l', below_fermi=True)
+    a, b, c, d = symbols('a,b,c,d', above_fermi=True)
+    p, q, r, s = symbols('p,q,r,s')
+    D = KroneckerDelta
+
+    assert C(Fd(a), F(i)) == -2*NO(F(i)*Fd(a))
+    assert C(Fd(j), NO(Fd(a)*F(i))).doit(wicks=True) == -D(j, i)*Fd(a)
+    assert C(Fd(a)*F(i), Fd(b)*F(j)).doit(wicks=True) == 0
+
+    c1 = Commutator(F(a), Fd(a))
+    assert Commutator.eval(c1, c1) == 0
+    c = Commutator(Fd(a)*F(i),Fd(b)*F(j))
+    assert latex(c) == r'\left[{a^\dagger_{a}} a_{i},{a^\dagger_{b}} a_{j}\right]'
+    assert repr(c) == 'Commutator(CreateFermion(a)*AnnihilateFermion(i),CreateFermion(b)*AnnihilateFermion(j))'
+    assert str(c) == '[CreateFermion(a)*AnnihilateFermion(i),CreateFermion(b)*AnnihilateFermion(j)]'
+
+
+def test_create_f():
+    i, j, n, m = symbols('i,j,n,m')
+    o = Fd(i)
+    assert isinstance(o, CreateFermion)
+    o = o.subs(i, j)
+    assert o.atoms(Symbol) == {j}
+    o = Fd(1)
+    assert o.apply_operator(FKet([n])) == FKet([1, n])
+    assert o.apply_operator(FKet([n])) == -FKet([n, 1])
+    o = Fd(n)
+    assert o.apply_operator(FKet([])) == FKet([n])
+
+    vacuum = FKet([], fermi_level=4)
+    assert vacuum == FKet([], fermi_level=4)
+
+    i, j, k, l = symbols('i,j,k,l', below_fermi=True)
+    a, b, c, d = symbols('a,b,c,d', above_fermi=True)
+    p, q, r, s = symbols('p,q,r,s')
+    p1 = symbols("p1")
+
+    assert Fd(i).apply_operator(FKet([i, j, k], 4)) == FKet([j, k], 4)
+    assert Fd(a).apply_operator(FKet([i, b, k], 4)) == FKet([a, i, b, k], 4)
+
+    assert Dagger(B(p)).apply_operator(q) == q*CreateBoson(p)
+    assert repr(Fd(p)) == 'CreateFermion(p)'
+    assert srepr(Fd(p)) == "CreateFermion(Symbol('p'))"
+    assert latex(Fd(p)) == r'{a^\dagger_{p}}'
+    assert latex(Fd(p1)) == r'{a^\dagger_{p_{1}}}'
+    assert latex(FKet([a,i], 1)) == r"\left|\left( a, \  i\right)\right\rangle"
+    assert latex(FKet([j,i,b,a], 2)) == r"\left|\left( a, \  b, \  i, \  j\right)\right\rangle"
+
+
+def test_annihilate_f():
+    i, j, n, m = symbols('i,j,n,m')
+    o = F(i)
+    assert isinstance(o, AnnihilateFermion)
+    o = o.subs(i, j)
+    assert o.atoms(Symbol) == {j}
+    o = F(1)
+    assert o.apply_operator(FKet([1, n])) == FKet([n])
+    assert o.apply_operator(FKet([n, 1])) == -FKet([n])
+    o = F(n)
+    assert o.apply_operator(FKet([n])) == FKet([])
+
+    i, j, k, l = symbols('i,j,k,l', below_fermi=True)
+    a, b, c, d = symbols('a,b,c,d', above_fermi=True)
+    p, q, r, s = symbols('p,q,r,s')
+    p1 = symbols('p1')
+
+    assert F(i).apply_operator(FKet([i, j, k], 4)) == 0
+    assert F(a).apply_operator(FKet([i, b, k], 4)) == 0
+    assert F(l).apply_operator(FKet([i, j, k], 3)) == 0
+    assert F(l).apply_operator(FKet([i, j, k], 4)) == FKet([l, i, j, k], 4)
+    assert str(F(p)) == 'f(p)'
+    assert repr(F(p)) == 'AnnihilateFermion(p)'
+    assert srepr(F(p)) == "AnnihilateFermion(Symbol('p'))"
+    assert latex(F(p)) == 'a_{p}'
+    assert latex(F(p1)) == 'a_{p_{1}}'
+
+
+def test_create_b():
+    i, j, n, m = symbols('i,j,n,m')
+    o = Bd(i)
+    assert isinstance(o, CreateBoson)
+    o = o.subs(i, j)
+    assert o.atoms(Symbol) == {j}
+    o = Bd(0)
+    assert o.apply_operator(BKet([n])) == sqrt(n + 1)*BKet([n + 1])
+    o = Bd(n)
+    assert o.apply_operator(BKet([n])) == o*BKet([n])
+
+
+def test_annihilate_b():
+    i, j, n, m = symbols('i,j,n,m')
+    o = B(i)
+    assert isinstance(o, AnnihilateBoson)
+    o = o.subs(i, j)
+    assert o.atoms(Symbol) == {j}
+    o = B(0)
+
+
+def test_wicks():
+    p, q, r, s = symbols('p,q,r,s', above_fermi=True)
+
+    # Testing for particles only
+
+    str = F(p)*Fd(q)
+    assert wicks(str) == NO(F(p)*Fd(q)) + KroneckerDelta(p, q)
+    str = Fd(p)*F(q)
+    assert wicks(str) == NO(Fd(p)*F(q))
+
+    str = F(p)*Fd(q)*F(r)*Fd(s)
+    nstr = wicks(str)
+    fasit = NO(
+        KroneckerDelta(p, q)*KroneckerDelta(r, s)
+        + KroneckerDelta(p, q)*AnnihilateFermion(r)*CreateFermion(s)
+        + KroneckerDelta(r, s)*AnnihilateFermion(p)*CreateFermion(q)
+        - KroneckerDelta(p, s)*AnnihilateFermion(r)*CreateFermion(q)
+        - AnnihilateFermion(p)*AnnihilateFermion(r)*CreateFermion(q)*CreateFermion(s))
+    assert nstr == fasit
+
+    assert (p*q*nstr).expand() == wicks(p*q*str)
+    assert (nstr*p*q*2).expand() == wicks(str*p*q*2)
+
+    # Testing CC equations particles and holes
+    i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
+    a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
+    p, q, r, s = symbols('p q r s', cls=Dummy)
+
+    assert (wicks(F(a)*NO(F(i)*F(j))*Fd(b)) ==
+            NO(F(a)*F(i)*F(j)*Fd(b)) +
+            KroneckerDelta(a, b)*NO(F(i)*F(j)))
+    assert (wicks(F(a)*NO(F(i)*F(j)*F(k))*Fd(b)) ==
+            NO(F(a)*F(i)*F(j)*F(k)*Fd(b)) -
+            KroneckerDelta(a, b)*NO(F(i)*F(j)*F(k)))
+
+    expr = wicks(Fd(i)*NO(Fd(j)*F(k))*F(l))
+    assert (expr ==
+           -KroneckerDelta(i, k)*NO(Fd(j)*F(l)) -
+            KroneckerDelta(j, l)*NO(Fd(i)*F(k)) -
+            KroneckerDelta(i, k)*KroneckerDelta(j, l) +
+            KroneckerDelta(i, l)*NO(Fd(j)*F(k)) +
+            NO(Fd(i)*Fd(j)*F(k)*F(l)))
+    expr = wicks(F(a)*NO(F(b)*Fd(c))*Fd(d))
+    assert (expr ==
+           -KroneckerDelta(a, c)*NO(F(b)*Fd(d)) -
+            KroneckerDelta(b, d)*NO(F(a)*Fd(c)) -
+            KroneckerDelta(a, c)*KroneckerDelta(b, d) +
+            KroneckerDelta(a, d)*NO(F(b)*Fd(c)) +
+            NO(F(a)*F(b)*Fd(c)*Fd(d)))
+
+
+def test_NO():
+    i, j, k, l = symbols('i j k l', below_fermi=True)
+    a, b, c, d = symbols('a b c d', above_fermi=True)
+    p, q, r, s = symbols('p q r s', cls=Dummy)
+
+    assert (NO(Fd(p)*F(q) + Fd(a)*F(b)) ==
+       NO(Fd(p)*F(q)) + NO(Fd(a)*F(b)))
+    assert (NO(Fd(i)*NO(F(j)*Fd(a))) ==
+       NO(Fd(i)*F(j)*Fd(a)))
+    assert NO(1) == 1
+    assert NO(i) == i
+    assert (NO(Fd(a)*Fd(b)*(F(c) + F(d))) ==
+            NO(Fd(a)*Fd(b)*F(c)) +
+            NO(Fd(a)*Fd(b)*F(d)))
+
+    assert NO(Fd(a)*F(b))._remove_brackets() == Fd(a)*F(b)
+    assert NO(F(j)*Fd(i))._remove_brackets() == F(j)*Fd(i)
+
+    assert (NO(Fd(p)*F(q)).subs(Fd(p), Fd(a) + Fd(i)) ==
+            NO(Fd(a)*F(q)) + NO(Fd(i)*F(q)))
+    assert (NO(Fd(p)*F(q)).subs(F(q), F(a) + F(i)) ==
+            NO(Fd(p)*F(a)) + NO(Fd(p)*F(i)))
+
+    expr = NO(Fd(p)*F(q))._remove_brackets()
+    assert wicks(expr) == NO(expr)
+
+    assert NO(Fd(a)*F(b)) == - NO(F(b)*Fd(a))
+
+    no = NO(Fd(a)*F(i)*F(b)*Fd(j))
+    l1 = list(no.iter_q_creators())
+    assert l1 == [0, 1]
+    l2 = list(no.iter_q_annihilators())
+    assert l2 == [3, 2]
+    no = NO(Fd(a)*Fd(i))
+    assert no.has_q_creators == 1
+    assert no.has_q_annihilators == -1
+    assert str(no) == ':CreateFermion(a)*CreateFermion(i):'
+    assert repr(no) == 'NO(CreateFermion(a)*CreateFermion(i))'
+    assert latex(no) == r'\left\{{a^\dagger_{a}} {a^\dagger_{i}}\right\}'
+    raises(NotImplementedError, lambda:  NO(Bd(p)*F(q)))
+
+
+def test_sorting():
+    i, j = symbols('i,j', below_fermi=True)
+    a, b = symbols('a,b', above_fermi=True)
+    p, q = symbols('p,q')
+
+    # p, q
+    assert _sort_anticommuting_fermions([Fd(p), F(q)]) == ([Fd(p), F(q)], 0)
+    assert _sort_anticommuting_fermions([F(p), Fd(q)]) == ([Fd(q), F(p)], 1)
+
+    # i, p
+    assert _sort_anticommuting_fermions([F(p), Fd(i)]) == ([F(p), Fd(i)], 0)
+    assert _sort_anticommuting_fermions([Fd(i), F(p)]) == ([F(p), Fd(i)], 1)
+    assert _sort_anticommuting_fermions([Fd(p), Fd(i)]) == ([Fd(p), Fd(i)], 0)
+    assert _sort_anticommuting_fermions([Fd(i), Fd(p)]) == ([Fd(p), Fd(i)], 1)
+    assert _sort_anticommuting_fermions([F(p), F(i)]) == ([F(i), F(p)], 1)
+    assert _sort_anticommuting_fermions([F(i), F(p)]) == ([F(i), F(p)], 0)
+    assert _sort_anticommuting_fermions([Fd(p), F(i)]) == ([F(i), Fd(p)], 1)
+    assert _sort_anticommuting_fermions([F(i), Fd(p)]) == ([F(i), Fd(p)], 0)
+
+    # a, p
+    assert _sort_anticommuting_fermions([F(p), Fd(a)]) == ([Fd(a), F(p)], 1)
+    assert _sort_anticommuting_fermions([Fd(a), F(p)]) == ([Fd(a), F(p)], 0)
+    assert _sort_anticommuting_fermions([Fd(p), Fd(a)]) == ([Fd(a), Fd(p)], 1)
+    assert _sort_anticommuting_fermions([Fd(a), Fd(p)]) == ([Fd(a), Fd(p)], 0)
+    assert _sort_anticommuting_fermions([F(p), F(a)]) == ([F(p), F(a)], 0)
+    assert _sort_anticommuting_fermions([F(a), F(p)]) == ([F(p), F(a)], 1)
+    assert _sort_anticommuting_fermions([Fd(p), F(a)]) == ([Fd(p), F(a)], 0)
+    assert _sort_anticommuting_fermions([F(a), Fd(p)]) == ([Fd(p), F(a)], 1)
+
+    # i, a
+    assert _sort_anticommuting_fermions([F(i), Fd(j)]) == ([F(i), Fd(j)], 0)
+    assert _sort_anticommuting_fermions([Fd(j), F(i)]) == ([F(i), Fd(j)], 1)
+    assert _sort_anticommuting_fermions([Fd(a), Fd(i)]) == ([Fd(a), Fd(i)], 0)
+    assert _sort_anticommuting_fermions([Fd(i), Fd(a)]) == ([Fd(a), Fd(i)], 1)
+    assert _sort_anticommuting_fermions([F(a), F(i)]) == ([F(i), F(a)], 1)
+    assert _sort_anticommuting_fermions([F(i), F(a)]) == ([F(i), F(a)], 0)
+
+
+def test_contraction():
+    i, j, k, l = symbols('i,j,k,l', below_fermi=True)
+    a, b, c, d = symbols('a,b,c,d', above_fermi=True)
+    p, q, r, s = symbols('p,q,r,s')
+    assert contraction(Fd(i), F(j)) == KroneckerDelta(i, j)
+    assert contraction(F(a), Fd(b)) == KroneckerDelta(a, b)
+    assert contraction(F(a), Fd(i)) == 0
+    assert contraction(Fd(a), F(i)) == 0
+    assert contraction(F(i), Fd(a)) == 0
+    assert contraction(Fd(i), F(a)) == 0
+    assert contraction(Fd(i), F(p)) == KroneckerDelta(i, p)
+    restr = evaluate_deltas(contraction(Fd(p), F(q)))
+    assert restr.is_only_below_fermi
+    restr = evaluate_deltas(contraction(F(p), Fd(q)))
+    assert restr.is_only_above_fermi
+    raises(ContractionAppliesOnlyToFermions, lambda: contraction(B(a), Fd(b)))
+
+
+def test_evaluate_deltas():
+    i, j, k = symbols('i,j,k')
+
+    r = KroneckerDelta(i, j) * KroneckerDelta(j, k)
+    assert evaluate_deltas(r) == KroneckerDelta(i, k)
+
+    r = KroneckerDelta(i, 0) * KroneckerDelta(j, k)
+    assert evaluate_deltas(r) == KroneckerDelta(i, 0) * KroneckerDelta(j, k)
+
+    r = KroneckerDelta(1, j) * KroneckerDelta(j, k)
+    assert evaluate_deltas(r) == KroneckerDelta(1, k)
+
+    r = KroneckerDelta(j, 2) * KroneckerDelta(k, j)
+    assert evaluate_deltas(r) == KroneckerDelta(2, k)
+
+    r = KroneckerDelta(i, 0) * KroneckerDelta(i, j) * KroneckerDelta(j, 1)
+    assert evaluate_deltas(r) == 0
+
+    r = (KroneckerDelta(0, i) * KroneckerDelta(0, j)
+         * KroneckerDelta(1, j) * KroneckerDelta(1, j))
+    assert evaluate_deltas(r) == 0
+
+
+def test_Tensors():
+    i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
+    a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
+    p, q, r, s = symbols('p q r s')
+
+    AT = AntiSymmetricTensor
+    assert AT('t', (a, b), (i, j)) == -AT('t', (b, a), (i, j))
+    assert AT('t', (a, b), (i, j)) == AT('t', (b, a), (j, i))
+    assert AT('t', (a, b), (i, j)) == -AT('t', (a, b), (j, i))
+    assert AT('t', (a, a), (i, j)) == 0
+    assert AT('t', (a, b), (i, i)) == 0
+    assert AT('t', (a, b, c), (i, j)) == -AT('t', (b, a, c), (i, j))
+    assert AT('t', (a, b, c), (i, j, k)) == AT('t', (b, a, c), (i, k, j))
+
+    tabij = AT('t', (a, b), (i, j))
+    assert tabij.has(a)
+    assert tabij.has(b)
+    assert tabij.has(i)
+    assert tabij.has(j)
+    assert tabij.subs(b, c) == AT('t', (a, c), (i, j))
+    assert (2*tabij).subs(i, c) == 2*AT('t', (a, b), (c, j))
+    assert tabij.symbol == Symbol('t')
+    assert latex(tabij) == '{t^{ab}_{ij}}'
+    assert str(tabij) == 't((_a, _b),(_i, _j))'
+
+    assert AT('t', (a, a), (i, j)).subs(a, b) == AT('t', (b, b), (i, j))
+    assert AT('t', (a, i), (a, j)).subs(a, b) == AT('t', (b, i), (b, j))
+
+    a1, a2, a3, a4 = symbols('alpha1:5')
+    u_alpha1234 = AntiSymmetricTensor("u", (a1, a2), (a3, a4))
+
+    assert latex(u_alpha1234) == r'{u^{\alpha_{1}\alpha_{2}}_{\alpha_{3}\alpha_{4}}}'
+    assert str(u_alpha1234) == 'u((alpha1, alpha2),(alpha3, alpha4))'
+
+
+def test_fully_contracted():
+    i, j, k, l = symbols('i j k l', below_fermi=True)
+    a, b, c, d = symbols('a b c d', above_fermi=True)
+    p, q, r, s = symbols('p q r s', cls=Dummy)
+
+    Fock = (AntiSymmetricTensor('f', (p,), (q,))*
+            NO(Fd(p)*F(q)))
+    V = (AntiSymmetricTensor('v', (p, q), (r, s))*
+         NO(Fd(p)*Fd(q)*F(s)*F(r)))/4
+
+    Fai = wicks(NO(Fd(i)*F(a))*Fock,
+            keep_only_fully_contracted=True,
+            simplify_kronecker_deltas=True)
+    assert Fai == AntiSymmetricTensor('f', (a,), (i,))
+    Vabij = wicks(NO(Fd(i)*Fd(j)*F(b)*F(a))*V,
+            keep_only_fully_contracted=True,
+            simplify_kronecker_deltas=True)
+    assert Vabij == AntiSymmetricTensor('v', (a, b), (i, j))
+
+
+def test_substitute_dummies_without_dummies():
+    i, j = symbols('i,j')
+    assert substitute_dummies(att(i, j) + 2) == att(i, j) + 2
+    assert substitute_dummies(att(i, j) + 1) == att(i, j) + 1
+
+
+def test_substitute_dummies_NO_operator():
+    i, j = symbols('i j', cls=Dummy)
+    assert substitute_dummies(att(i, j)*NO(Fd(i)*F(j))
+                - att(j, i)*NO(Fd(j)*F(i))) == 0
+
+
+def test_substitute_dummies_SQ_operator():
+    i, j = symbols('i j', cls=Dummy)
+    assert substitute_dummies(att(i, j)*Fd(i)*F(j)
+                - att(j, i)*Fd(j)*F(i)) == 0
+
+
+def test_substitute_dummies_new_indices():
+    i, j = symbols('i j', below_fermi=True, cls=Dummy)
+    a, b = symbols('a b', above_fermi=True, cls=Dummy)
+    p, q = symbols('p q', cls=Dummy)
+    f = Function('f')
+    assert substitute_dummies(f(i, a, p) - f(j, b, q), new_indices=True) == 0
+
+
+def test_substitute_dummies_substitution_order():
+    i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
+    f = Function('f')
+    from sympy.utilities.iterables import variations
+    for permut in variations([i, j, k, l], 4):
+        assert substitute_dummies(f(*permut) - f(i, j, k, l)) == 0
+
+
+def test_dummy_order_inner_outer_lines_VT1T1T1():
+    ii = symbols('i', below_fermi=True)
+    aa = symbols('a', above_fermi=True)
+    k, l = symbols('k l', below_fermi=True, cls=Dummy)
+    c, d = symbols('c d', above_fermi=True, cls=Dummy)
+
+    v = Function('v')
+    t = Function('t')
+    dums = _get_ordered_dummies
+
+    # Coupled-Cluster T1 terms with V*T1*T1*T1
+    # t^{a}_{k} t^{c}_{i} t^{d}_{l} v^{lk}_{dc}
+    exprs = [
+        # permut v and t <=> swapping internal lines, equivalent
+        # irrespective of symmetries in v
+        v(k, l, c, d)*t(c, ii)*t(d, l)*t(aa, k),
+        v(l, k, c, d)*t(c, ii)*t(d, k)*t(aa, l),
+        v(k, l, d, c)*t(d, ii)*t(c, l)*t(aa, k),
+        v(l, k, d, c)*t(d, ii)*t(c, k)*t(aa, l),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_dummy_order_inner_outer_lines_VT1T1T1T1():
+    ii, jj = symbols('i j', below_fermi=True)
+    aa, bb = symbols('a b', above_fermi=True)
+    k, l = symbols('k l', below_fermi=True, cls=Dummy)
+    c, d = symbols('c d', above_fermi=True, cls=Dummy)
+
+    v = Function('v')
+    t = Function('t')
+    dums = _get_ordered_dummies
+
+    # Coupled-Cluster T2 terms with V*T1*T1*T1*T1
+    exprs = [
+        # permut t <=> swapping external lines, not equivalent
+        # except if v has certain symmetries.
+        v(k, l, c, d)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
+        v(k, l, c, d)*t(c, jj)*t(d, ii)*t(aa, k)*t(bb, l),
+        v(k, l, c, d)*t(c, ii)*t(d, jj)*t(bb, k)*t(aa, l),
+        v(k, l, c, d)*t(c, jj)*t(d, ii)*t(bb, k)*t(aa, l),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+    exprs = [
+        # permut v <=> swapping external lines, not equivalent
+        # except if v has certain symmetries.
+        #
+        # Note that in contrast to above, these permutations have identical
+        # dummy order.  That is because the proximity to external indices
+        # has higher influence on the canonical dummy ordering than the
+        # position of a dummy on the factors.  In fact, the terms here are
+        # similar in structure as the result of the dummy substitutions above.
+        v(k, l, c, d)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
+        v(l, k, c, d)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
+        v(k, l, d, c)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
+        v(l, k, d, c)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) == dums(permut)
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+    exprs = [
+        # permut t and v <=> swapping internal lines, equivalent.
+        # Canonical dummy order is different, and a consistent
+        # substitution reveals the equivalence.
+        v(k, l, c, d)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
+        v(k, l, d, c)*t(c, jj)*t(d, ii)*t(aa, k)*t(bb, l),
+        v(l, k, c, d)*t(c, ii)*t(d, jj)*t(bb, k)*t(aa, l),
+        v(l, k, d, c)*t(c, jj)*t(d, ii)*t(bb, k)*t(aa, l),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_get_subNO():
+    p, q, r = symbols('p,q,r')
+    assert NO(F(p)*F(q)*F(r)).get_subNO(1) == NO(F(p)*F(r))
+    assert NO(F(p)*F(q)*F(r)).get_subNO(0) == NO(F(q)*F(r))
+    assert NO(F(p)*F(q)*F(r)).get_subNO(2) == NO(F(p)*F(q))
+
+
+def test_equivalent_internal_lines_VT1T1():
+    i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
+    a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
+
+    v = Function('v')
+    t = Function('t')
+    dums = _get_ordered_dummies
+
+    exprs = [  # permute v.  Different dummy order. Not equivalent.
+        v(i, j, a, b)*t(a, i)*t(b, j),
+        v(j, i, a, b)*t(a, i)*t(b, j),
+        v(i, j, b, a)*t(a, i)*t(b, j),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+
+    exprs = [  # permute v.  Different dummy order. Equivalent
+        v(i, j, a, b)*t(a, i)*t(b, j),
+        v(j, i, b, a)*t(a, i)*t(b, j),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+    exprs = [  # permute t.  Same dummy order, not equivalent.
+        v(i, j, a, b)*t(a, i)*t(b, j),
+        v(i, j, a, b)*t(b, i)*t(a, j),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) == dums(permut)
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+
+    exprs = [  # permute v and t.  Different dummy order, equivalent
+        v(i, j, a, b)*t(a, i)*t(b, j),
+        v(j, i, a, b)*t(a, j)*t(b, i),
+        v(i, j, b, a)*t(b, i)*t(a, j),
+        v(j, i, b, a)*t(b, j)*t(a, i),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_equivalent_internal_lines_VT2conjT2():
+    # this diagram requires special handling in TCE
+    i, j, k, l, m, n = symbols('i j k l m n', below_fermi=True, cls=Dummy)
+    a, b, c, d, e, f = symbols('a b c d e f', above_fermi=True, cls=Dummy)
+    p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
+    h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
+
+    from sympy.utilities.iterables import variations
+
+    v = Function('v')
+    t = Function('t')
+    dums = _get_ordered_dummies
+
+    # v(abcd)t(abij)t(ijcd)
+    template = v(p1, p2, p3, p4)*t(p1, p2, i, j)*t(i, j, p3, p4)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert dums(base) != dums(expr)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+    template = v(p1, p2, p3, p4)*t(p1, p2, j, i)*t(j, i, p3, p4)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert dums(base) != dums(expr)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+    # v(abcd)t(abij)t(jicd)
+    template = v(p1, p2, p3, p4)*t(p1, p2, i, j)*t(j, i, p3, p4)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert dums(base) != dums(expr)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+    template = v(p1, p2, p3, p4)*t(p1, p2, j, i)*t(i, j, p3, p4)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert dums(base) != dums(expr)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+
+def test_equivalent_internal_lines_VT2conjT2_ambiguous_order():
+    # These diagrams invokes _determine_ambiguous() because the
+    # dummies can not be ordered unambiguously by the key alone
+    i, j, k, l, m, n = symbols('i j k l m n', below_fermi=True, cls=Dummy)
+    a, b, c, d, e, f = symbols('a b c d e f', above_fermi=True, cls=Dummy)
+    p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
+    h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
+
+    from sympy.utilities.iterables import variations
+
+    v = Function('v')
+    t = Function('t')
+    dums = _get_ordered_dummies
+
+    # v(abcd)t(abij)t(cdij)
+    template = v(p1, p2, p3, p4)*t(p1, p2, i, j)*t(p3, p4, i, j)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert dums(base) != dums(expr)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+    template = v(p1, p2, p3, p4)*t(p1, p2, j, i)*t(p3, p4, i, j)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert dums(base) != dums(expr)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+
+def test_equivalent_internal_lines_VT2():
+    i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
+    a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
+
+    v = Function('v')
+    t = Function('t')
+    dums = _get_ordered_dummies
+    exprs = [
+        # permute v. Same dummy order, not equivalent.
+        #
+        # This test show that the dummy order may not be sensitive to all
+        # index permutations.  The following expressions have identical
+        # structure as the resulting terms from of the dummy substitutions
+        # in the test above.  Here, all expressions have the same dummy
+        # order, so they cannot be simplified by means of dummy
+        # substitution.  In order to simplify further, it is necessary to
+        # exploit symmetries in the objects, for instance if t or v is
+        # antisymmetric.
+        v(i, j, a, b)*t(a, b, i, j),
+        v(j, i, a, b)*t(a, b, i, j),
+        v(i, j, b, a)*t(a, b, i, j),
+        v(j, i, b, a)*t(a, b, i, j),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) == dums(permut)
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+
+    exprs = [
+        # permute t.
+        v(i, j, a, b)*t(a, b, i, j),
+        v(i, j, a, b)*t(b, a, i, j),
+        v(i, j, a, b)*t(a, b, j, i),
+        v(i, j, a, b)*t(b, a, j, i),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+
+    exprs = [  # permute v and t.  Relabelling of dummies should be equivalent.
+        v(i, j, a, b)*t(a, b, i, j),
+        v(j, i, a, b)*t(a, b, j, i),
+        v(i, j, b, a)*t(b, a, i, j),
+        v(j, i, b, a)*t(b, a, j, i),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_internal_external_VT2T2():
+    ii, jj = symbols('i j', below_fermi=True)
+    aa, bb = symbols('a b', above_fermi=True)
+    k, l = symbols('k l', below_fermi=True, cls=Dummy)
+    c, d = symbols('c d', above_fermi=True, cls=Dummy)
+
+    v = Function('v')
+    t = Function('t')
+    dums = _get_ordered_dummies
+
+    exprs = [
+        v(k, l, c, d)*t(aa, c, ii, k)*t(bb, d, jj, l),
+        v(l, k, c, d)*t(aa, c, ii, l)*t(bb, d, jj, k),
+        v(k, l, d, c)*t(aa, d, ii, k)*t(bb, c, jj, l),
+        v(l, k, d, c)*t(aa, d, ii, l)*t(bb, c, jj, k),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+    exprs = [
+        v(k, l, c, d)*t(aa, c, ii, k)*t(d, bb, jj, l),
+        v(l, k, c, d)*t(aa, c, ii, l)*t(d, bb, jj, k),
+        v(k, l, d, c)*t(aa, d, ii, k)*t(c, bb, jj, l),
+        v(l, k, d, c)*t(aa, d, ii, l)*t(c, bb, jj, k),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+    exprs = [
+        v(k, l, c, d)*t(c, aa, ii, k)*t(bb, d, jj, l),
+        v(l, k, c, d)*t(c, aa, ii, l)*t(bb, d, jj, k),
+        v(k, l, d, c)*t(d, aa, ii, k)*t(bb, c, jj, l),
+        v(l, k, d, c)*t(d, aa, ii, l)*t(bb, c, jj, k),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_internal_external_pqrs():
+    ii, jj = symbols('i j')
+    aa, bb = symbols('a b')
+    k, l = symbols('k l', cls=Dummy)
+    c, d = symbols('c d', cls=Dummy)
+
+    v = Function('v')
+    t = Function('t')
+    dums = _get_ordered_dummies
+
+    exprs = [
+        v(k, l, c, d)*t(aa, c, ii, k)*t(bb, d, jj, l),
+        v(l, k, c, d)*t(aa, c, ii, l)*t(bb, d, jj, k),
+        v(k, l, d, c)*t(aa, d, ii, k)*t(bb, c, jj, l),
+        v(l, k, d, c)*t(aa, d, ii, l)*t(bb, c, jj, k),
+    ]
+    for permut in exprs[1:]:
+        assert dums(exprs[0]) != dums(permut)
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_dummy_order_well_defined():
+    aa, bb = symbols('a b', above_fermi=True)
+    k, l, m = symbols('k l m', below_fermi=True, cls=Dummy)
+    c, d = symbols('c d', above_fermi=True, cls=Dummy)
+    p, q = symbols('p q', cls=Dummy)
+
+    A = Function('A')
+    B = Function('B')
+    C = Function('C')
+    dums = _get_ordered_dummies
+
+    # We go through all key components in the order of increasing priority,
+    # and consider only fully orderable expressions.  Non-orderable expressions
+    # are tested elsewhere.
+
+    # pos in first factor determines sort order
+    assert dums(A(k, l)*B(l, k)) == [k, l]
+    assert dums(A(l, k)*B(l, k)) == [l, k]
+    assert dums(A(k, l)*B(k, l)) == [k, l]
+    assert dums(A(l, k)*B(k, l)) == [l, k]
+
+    # factors involving the index
+    assert dums(A(k, l)*B(l, m)*C(k, m)) == [l, k, m]
+    assert dums(A(k, l)*B(l, m)*C(m, k)) == [l, k, m]
+    assert dums(A(l, k)*B(l, m)*C(k, m)) == [l, k, m]
+    assert dums(A(l, k)*B(l, m)*C(m, k)) == [l, k, m]
+    assert dums(A(k, l)*B(m, l)*C(k, m)) == [l, k, m]
+    assert dums(A(k, l)*B(m, l)*C(m, k)) == [l, k, m]
+    assert dums(A(l, k)*B(m, l)*C(k, m)) == [l, k, m]
+    assert dums(A(l, k)*B(m, l)*C(m, k)) == [l, k, m]
+
+    # same, but with factor order determined by non-dummies
+    assert dums(A(k, aa, l)*A(l, bb, m)*A(bb, k, m)) == [l, k, m]
+    assert dums(A(k, aa, l)*A(l, bb, m)*A(bb, m, k)) == [l, k, m]
+    assert dums(A(k, aa, l)*A(m, bb, l)*A(bb, k, m)) == [l, k, m]
+    assert dums(A(k, aa, l)*A(m, bb, l)*A(bb, m, k)) == [l, k, m]
+    assert dums(A(l, aa, k)*A(l, bb, m)*A(bb, k, m)) == [l, k, m]
+    assert dums(A(l, aa, k)*A(l, bb, m)*A(bb, m, k)) == [l, k, m]
+    assert dums(A(l, aa, k)*A(m, bb, l)*A(bb, k, m)) == [l, k, m]
+    assert dums(A(l, aa, k)*A(m, bb, l)*A(bb, m, k)) == [l, k, m]
+
+    # index range
+    assert dums(A(p, c, k)*B(p, c, k)) == [k, c, p]
+    assert dums(A(p, k, c)*B(p, c, k)) == [k, c, p]
+    assert dums(A(c, k, p)*B(p, c, k)) == [k, c, p]
+    assert dums(A(c, p, k)*B(p, c, k)) == [k, c, p]
+    assert dums(A(k, c, p)*B(p, c, k)) == [k, c, p]
+    assert dums(A(k, p, c)*B(p, c, k)) == [k, c, p]
+    assert dums(B(p, c, k)*A(p, c, k)) == [k, c, p]
+    assert dums(B(p, k, c)*A(p, c, k)) == [k, c, p]
+    assert dums(B(c, k, p)*A(p, c, k)) == [k, c, p]
+    assert dums(B(c, p, k)*A(p, c, k)) == [k, c, p]
+    assert dums(B(k, c, p)*A(p, c, k)) == [k, c, p]
+    assert dums(B(k, p, c)*A(p, c, k)) == [k, c, p]
+
+
+def test_dummy_order_ambiguous():
+    aa, bb = symbols('a b', above_fermi=True)
+    i, j, k, l, m = symbols('i j k l m', below_fermi=True, cls=Dummy)
+    a, b, c, d, e = symbols('a b c d e', above_fermi=True, cls=Dummy)
+    p, q = symbols('p q', cls=Dummy)
+    p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
+    p5, p6, p7, p8 = symbols('p5 p6 p7 p8', above_fermi=True, cls=Dummy)
+    h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
+    h5, h6, h7, h8 = symbols('h5 h6 h7 h8', below_fermi=True, cls=Dummy)
+
+    A = Function('A')
+    B = Function('B')
+
+    from sympy.utilities.iterables import variations
+
+    # A*A*A*A*B  --  ordering of p5 and p4 is used to figure out the rest
+    template = A(p1, p2)*A(p4, p1)*A(p2, p3)*A(p3, p5)*B(p5, p4)
+    permutator = variations([a, b, c, d, e], 5)
+    base = template.subs(zip([p1, p2, p3, p4, p5], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4, p5], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+    # A*A*A*A*A  --  an arbitrary index is assigned and the rest are figured out
+    template = A(p1, p2)*A(p4, p1)*A(p2, p3)*A(p3, p5)*A(p5, p4)
+    permutator = variations([a, b, c, d, e], 5)
+    base = template.subs(zip([p1, p2, p3, p4, p5], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4, p5], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+    # A*A*A  --  ordering of p5 and p4 is used to figure out the rest
+    template = A(p1, p2, p4, p1)*A(p2, p3, p3, p5)*A(p5, p4)
+    permutator = variations([a, b, c, d, e], 5)
+    base = template.subs(zip([p1, p2, p3, p4, p5], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4, p5], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+
+def atv(*args):
+    return AntiSymmetricTensor('v', args[:2], args[2:] )
+
+
+def att(*args):
+    if len(args) == 4:
+        return AntiSymmetricTensor('t', args[:2], args[2:] )
+    elif len(args) == 2:
+        return AntiSymmetricTensor('t', (args[0],), (args[1],))
+
+
+def test_dummy_order_inner_outer_lines_VT1T1T1_AT():
+    ii = symbols('i', below_fermi=True)
+    aa = symbols('a', above_fermi=True)
+    k, l = symbols('k l', below_fermi=True, cls=Dummy)
+    c, d = symbols('c d', above_fermi=True, cls=Dummy)
+
+    # Coupled-Cluster T1 terms with V*T1*T1*T1
+    # t^{a}_{k} t^{c}_{i} t^{d}_{l} v^{lk}_{dc}
+    exprs = [
+        # permut v and t <=> swapping internal lines, equivalent
+        # irrespective of symmetries in v
+        atv(k, l, c, d)*att(c, ii)*att(d, l)*att(aa, k),
+        atv(l, k, c, d)*att(c, ii)*att(d, k)*att(aa, l),
+        atv(k, l, d, c)*att(d, ii)*att(c, l)*att(aa, k),
+        atv(l, k, d, c)*att(d, ii)*att(c, k)*att(aa, l),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_dummy_order_inner_outer_lines_VT1T1T1T1_AT():
+    ii, jj = symbols('i j', below_fermi=True)
+    aa, bb = symbols('a b', above_fermi=True)
+    k, l = symbols('k l', below_fermi=True, cls=Dummy)
+    c, d = symbols('c d', above_fermi=True, cls=Dummy)
+
+    # Coupled-Cluster T2 terms with V*T1*T1*T1*T1
+    # non-equivalent substitutions (change of sign)
+    exprs = [
+        # permut t <=> swapping external lines
+        atv(k, l, c, d)*att(c, ii)*att(d, jj)*att(aa, k)*att(bb, l),
+        atv(k, l, c, d)*att(c, jj)*att(d, ii)*att(aa, k)*att(bb, l),
+        atv(k, l, c, d)*att(c, ii)*att(d, jj)*att(bb, k)*att(aa, l),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == -substitute_dummies(permut)
+
+    # equivalent substitutions
+    exprs = [
+        atv(k, l, c, d)*att(c, ii)*att(d, jj)*att(aa, k)*att(bb, l),
+        # permut t <=> swapping external lines
+        atv(k, l, c, d)*att(c, jj)*att(d, ii)*att(bb, k)*att(aa, l),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_equivalent_internal_lines_VT1T1_AT():
+    i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
+    a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
+
+    exprs = [  # permute v.  Different dummy order. Not equivalent.
+        atv(i, j, a, b)*att(a, i)*att(b, j),
+        atv(j, i, a, b)*att(a, i)*att(b, j),
+        atv(i, j, b, a)*att(a, i)*att(b, j),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+
+    exprs = [  # permute v.  Different dummy order. Equivalent
+        atv(i, j, a, b)*att(a, i)*att(b, j),
+        atv(j, i, b, a)*att(a, i)*att(b, j),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+    exprs = [  # permute t.  Same dummy order, not equivalent.
+        atv(i, j, a, b)*att(a, i)*att(b, j),
+        atv(i, j, a, b)*att(b, i)*att(a, j),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+
+    exprs = [  # permute v and t.  Different dummy order, equivalent
+        atv(i, j, a, b)*att(a, i)*att(b, j),
+        atv(j, i, a, b)*att(a, j)*att(b, i),
+        atv(i, j, b, a)*att(b, i)*att(a, j),
+        atv(j, i, b, a)*att(b, j)*att(a, i),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_equivalent_internal_lines_VT2conjT2_AT():
+    # this diagram requires special handling in TCE
+    i, j, k, l, m, n = symbols('i j k l m n', below_fermi=True, cls=Dummy)
+    a, b, c, d, e, f = symbols('a b c d e f', above_fermi=True, cls=Dummy)
+    p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
+    h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
+
+    from sympy.utilities.iterables import variations
+
+    # atv(abcd)att(abij)att(ijcd)
+    template = atv(p1, p2, p3, p4)*att(p1, p2, i, j)*att(i, j, p3, p4)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+    template = atv(p1, p2, p3, p4)*att(p1, p2, j, i)*att(j, i, p3, p4)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+    # atv(abcd)att(abij)att(jicd)
+    template = atv(p1, p2, p3, p4)*att(p1, p2, i, j)*att(j, i, p3, p4)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+    template = atv(p1, p2, p3, p4)*att(p1, p2, j, i)*att(i, j, p3, p4)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+
+def test_equivalent_internal_lines_VT2conjT2_ambiguous_order_AT():
+    # These diagrams invokes _determine_ambiguous() because the
+    # dummies can not be ordered unambiguously by the key alone
+    i, j, k, l, m, n = symbols('i j k l m n', below_fermi=True, cls=Dummy)
+    a, b, c, d, e, f = symbols('a b c d e f', above_fermi=True, cls=Dummy)
+    p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
+    h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
+
+    from sympy.utilities.iterables import variations
+
+    # atv(abcd)att(abij)att(cdij)
+    template = atv(p1, p2, p3, p4)*att(p1, p2, i, j)*att(p3, p4, i, j)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+    template = atv(p1, p2, p3, p4)*att(p1, p2, j, i)*att(p3, p4, i, j)
+    permutator = variations([a, b, c, d], 4)
+    base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
+    for permut in permutator:
+        subslist = zip([p1, p2, p3, p4], permut)
+        expr = template.subs(subslist)
+        assert substitute_dummies(expr) == substitute_dummies(base)
+
+
+def test_equivalent_internal_lines_VT2_AT():
+    i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
+    a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
+
+    exprs = [
+        # permute v. Same dummy order, not equivalent.
+        atv(i, j, a, b)*att(a, b, i, j),
+        atv(j, i, a, b)*att(a, b, i, j),
+        atv(i, j, b, a)*att(a, b, i, j),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+
+    exprs = [
+        # permute t.
+        atv(i, j, a, b)*att(a, b, i, j),
+        atv(i, j, a, b)*att(b, a, i, j),
+        atv(i, j, a, b)*att(a, b, j, i),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
+
+    exprs = [  # permute v and t.  Relabelling of dummies should be equivalent.
+        atv(i, j, a, b)*att(a, b, i, j),
+        atv(j, i, a, b)*att(a, b, j, i),
+        atv(i, j, b, a)*att(b, a, i, j),
+        atv(j, i, b, a)*att(b, a, j, i),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_internal_external_VT2T2_AT():
+    ii, jj = symbols('i j', below_fermi=True)
+    aa, bb = symbols('a b', above_fermi=True)
+    k, l = symbols('k l', below_fermi=True, cls=Dummy)
+    c, d = symbols('c d', above_fermi=True, cls=Dummy)
+
+    exprs = [
+        atv(k, l, c, d)*att(aa, c, ii, k)*att(bb, d, jj, l),
+        atv(l, k, c, d)*att(aa, c, ii, l)*att(bb, d, jj, k),
+        atv(k, l, d, c)*att(aa, d, ii, k)*att(bb, c, jj, l),
+        atv(l, k, d, c)*att(aa, d, ii, l)*att(bb, c, jj, k),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+    exprs = [
+        atv(k, l, c, d)*att(aa, c, ii, k)*att(d, bb, jj, l),
+        atv(l, k, c, d)*att(aa, c, ii, l)*att(d, bb, jj, k),
+        atv(k, l, d, c)*att(aa, d, ii, k)*att(c, bb, jj, l),
+        atv(l, k, d, c)*att(aa, d, ii, l)*att(c, bb, jj, k),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+    exprs = [
+        atv(k, l, c, d)*att(c, aa, ii, k)*att(bb, d, jj, l),
+        atv(l, k, c, d)*att(c, aa, ii, l)*att(bb, d, jj, k),
+        atv(k, l, d, c)*att(d, aa, ii, k)*att(bb, c, jj, l),
+        atv(l, k, d, c)*att(d, aa, ii, l)*att(bb, c, jj, k),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_internal_external_pqrs_AT():
+    ii, jj = symbols('i j')
+    aa, bb = symbols('a b')
+    k, l = symbols('k l', cls=Dummy)
+    c, d = symbols('c d', cls=Dummy)
+
+    exprs = [
+        atv(k, l, c, d)*att(aa, c, ii, k)*att(bb, d, jj, l),
+        atv(l, k, c, d)*att(aa, c, ii, l)*att(bb, d, jj, k),
+        atv(k, l, d, c)*att(aa, d, ii, k)*att(bb, c, jj, l),
+        atv(l, k, d, c)*att(aa, d, ii, l)*att(bb, c, jj, k),
+    ]
+    for permut in exprs[1:]:
+        assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
+
+
+def test_issue_19661():
+    a = Symbol('0')
+    assert latex(Commutator(Bd(a)**2, B(a))
+                 ) == '- \\left[b_{0},{b^\\dagger_{0}}^{2}\\right]'
+
+
+def test_canonical_ordering_AntiSymmetricTensor():
+    v = symbols("v")
+
+    c, d = symbols(('c','d'), above_fermi=True,
+                                   cls=Dummy)
+    k, l = symbols(('k','l'), below_fermi=True,
+                                   cls=Dummy)
+
+    # formerly, the left gave either the left or the right
+    assert AntiSymmetricTensor(v, (k, l), (d, c)
+        ) == -AntiSymmetricTensor(v, (l, k), (d, c))

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/tests/test_sho.py

@@ -0,0 +1,21 @@
+from sympy.core import symbols, Rational, Function, diff
+from sympy.physics.sho import R_nl, E_nl
+from sympy.simplify.simplify import simplify
+
+
+def test_sho_R_nl():
+    omega, r = symbols('omega r')
+    l = symbols('l', integer=True)
+    u = Function('u')
+
+    # check that it obeys the Schrodinger equation
+    for n in range(5):
+        schreq = ( -diff(u(r), r, 2)/2 + ((l*(l + 1))/(2*r**2)
+                    + omega**2*r**2/2 - E_nl(n, l, omega))*u(r) )
+        result = schreq.subs(u(r), r*R_nl(n, l, omega/2, r))
+        assert simplify(result.doit()) == 0
+
+
+def test_energy():
+    n, l, hw = symbols('n l hw')
+    assert simplify(E_nl(n, l, hw) - (2*n + l + Rational(3, 2))*hw) == 0

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/__init__.py

@@ -0,0 +1,453 @@
+# isort:skip_file
+"""
+Dimensional analysis and unit systems.
+
+This module defines dimension/unit systems and physical quantities. It is
+based on a group-theoretical construction where dimensions are represented as
+vectors (coefficients being the exponents), and units are defined as a dimension
+to which we added a scale.
+
+Quantities are built from a factor and a unit, and are the basic objects that
+one will use when doing computations.
+
+All objects except systems and prefixes can be used in SymPy expressions.
+Note that as part of a CAS, various objects do not combine automatically
+under operations.
+
+Details about the implementation can be found in the documentation, and we
+will not repeat all the explanations we gave there concerning our approach.
+Ideas about future developments can be found on the `Github wiki
+<https://github.com/sympy/sympy/wiki/Unit-systems>`_, and you should consult
+this page if you are willing to help.
+
+Useful functions:
+
+- ``find_unit``: easily lookup pre-defined units.
+- ``convert_to(expr, newunit)``: converts an expression into the same
+    expression expressed in another unit.
+
+"""
+
+from .dimensions import Dimension, DimensionSystem
+from .unitsystem import UnitSystem
+from .util import convert_to
+from .quantities import Quantity
+
+from .definitions.dimension_definitions import (
+    amount_of_substance, acceleration, action, area,
+    capacitance, charge, conductance, current, energy,
+    force, frequency, impedance, inductance, length,
+    luminous_intensity, magnetic_density,
+    magnetic_flux, mass, momentum, power, pressure, temperature, time,
+    velocity, voltage, volume
+)
+
+Unit = Quantity
+
+speed = velocity
+luminosity = luminous_intensity
+magnetic_flux_density = magnetic_density
+amount = amount_of_substance
+
+from .prefixes import (
+    # 10-power based:
+    yotta,
+    zetta,
+    exa,
+    peta,
+    tera,
+    giga,
+    mega,
+    kilo,
+    hecto,
+    deca,
+    deci,
+    centi,
+    milli,
+    micro,
+    nano,
+    pico,
+    femto,
+    atto,
+    zepto,
+    yocto,
+    # 2-power based:
+    kibi,
+    mebi,
+    gibi,
+    tebi,
+    pebi,
+    exbi,
+)
+
+from .definitions import (
+    percent, percents,
+    permille,
+    rad, radian, radians,
+    deg, degree, degrees,
+    sr, steradian, steradians,
+    mil, angular_mil, angular_mils,
+    m, meter, meters,
+    kg, kilogram, kilograms,
+    s, second, seconds,
+    A, ampere, amperes,
+    K, kelvin, kelvins,
+    mol, mole, moles,
+    cd, candela, candelas,
+    g, gram, grams,
+    mg, milligram, milligrams,
+    ug, microgram, micrograms,
+    t, tonne, metric_ton,
+    newton, newtons, N,
+    joule, joules, J,
+    watt, watts, W,
+    pascal, pascals, Pa, pa,
+    hertz, hz, Hz,
+    coulomb, coulombs, C,
+    volt, volts, v, V,
+    ohm, ohms,
+    siemens, S, mho, mhos,
+    farad, farads, F,
+    henry, henrys, H,
+    tesla, teslas, T,
+    weber, webers, Wb, wb,
+    optical_power, dioptre, D,
+    lux, lx,
+    katal, kat,
+    gray, Gy,
+    becquerel, Bq,
+    km, kilometer, kilometers,
+    dm, decimeter, decimeters,
+    cm, centimeter, centimeters,
+    mm, millimeter, millimeters,
+    um, micrometer, micrometers, micron, microns,
+    nm, nanometer, nanometers,
+    pm, picometer, picometers,
+    ft, foot, feet,
+    inch, inches,
+    yd, yard, yards,
+    mi, mile, miles,
+    nmi, nautical_mile, nautical_miles,
+    angstrom, angstroms,
+    ha, hectare,
+    l, L, liter, liters,
+    dl, dL, deciliter, deciliters,
+    cl, cL, centiliter, centiliters,
+    ml, mL, milliliter, milliliters,
+    ms, millisecond, milliseconds,
+    us, microsecond, microseconds,
+    ns, nanosecond, nanoseconds,
+    ps, picosecond, picoseconds,
+    minute, minutes,
+    h, hour, hours,
+    day, days,
+    anomalistic_year, anomalistic_years,
+    sidereal_year, sidereal_years,
+    tropical_year, tropical_years,
+    common_year, common_years,
+    julian_year, julian_years,
+    draconic_year, draconic_years,
+    gaussian_year, gaussian_years,
+    full_moon_cycle, full_moon_cycles,
+    year, years,
+    G, gravitational_constant,
+    c, speed_of_light,
+    elementary_charge,
+    hbar,
+    planck,
+    eV, electronvolt, electronvolts,
+    avogadro_number,
+    avogadro, avogadro_constant,
+    boltzmann, boltzmann_constant,
+    stefan, stefan_boltzmann_constant,
+    R, molar_gas_constant,
+    faraday_constant,
+    josephson_constant,
+    von_klitzing_constant,
+    Da, dalton, amu, amus, atomic_mass_unit, atomic_mass_constant,
+    me, electron_rest_mass,
+    gee, gees, acceleration_due_to_gravity,
+    u0, magnetic_constant, vacuum_permeability,
+    e0, electric_constant, vacuum_permittivity,
+    Z0, vacuum_impedance,
+    coulomb_constant, electric_force_constant,
+    atmosphere, atmospheres, atm,
+    kPa,
+    bar, bars,
+    pound, pounds,
+    psi,
+    dHg0,
+    mmHg, torr,
+    mmu, mmus, milli_mass_unit,
+    quart, quarts,
+    ly, lightyear, lightyears,
+    au, astronomical_unit, astronomical_units,
+    planck_mass,
+    planck_time,
+    planck_temperature,
+    planck_length,
+    planck_charge,
+    planck_area,
+    planck_volume,
+    planck_momentum,
+    planck_energy,
+    planck_force,
+    planck_power,
+    planck_density,
+    planck_energy_density,
+    planck_intensity,
+    planck_angular_frequency,
+    planck_pressure,
+    planck_current,
+    planck_voltage,
+    planck_impedance,
+    planck_acceleration,
+    bit, bits,
+    byte,
+    kibibyte, kibibytes,
+    mebibyte, mebibytes,
+    gibibyte, gibibytes,
+    tebibyte, tebibytes,
+    pebibyte, pebibytes,
+    exbibyte, exbibytes,
+)
+
+from .systems import (
+    mks, mksa, si
+)
+
+
+def find_unit(quantity, unit_system="SI"):
+    """
+    Return a list of matching units or dimension names.
+
+    - If ``quantity`` is a string -- units/dimensions containing the string
+    `quantity`.
+    - If ``quantity`` is a unit or dimension -- units having matching base
+    units or dimensions.
+
+    Examples
+    ========
+
+    >>> from sympy.physics import units as u
+    >>> u.find_unit('charge')
+    ['C', 'coulomb', 'coulombs', 'planck_charge', 'elementary_charge']
+    >>> u.find_unit(u.charge)
+    ['C', 'coulomb', 'coulombs', 'planck_charge', 'elementary_charge']
+    >>> u.find_unit("ampere")
+    ['ampere', 'amperes']
+    >>> u.find_unit('angstrom')
+    ['angstrom', 'angstroms']
+    >>> u.find_unit('volt')
+    ['volt', 'volts', 'electronvolt', 'electronvolts', 'planck_voltage']
+    >>> u.find_unit(u.inch**3)[:9]
+    ['L', 'l', 'cL', 'cl', 'dL', 'dl', 'mL', 'ml', 'liter']
+    """
+    unit_system = UnitSystem.get_unit_system(unit_system)
+
+    import sympy.physics.units as u
+    rv = []
+    if isinstance(quantity, str):
+        rv = [i for i in dir(u) if quantity in i and isinstance(getattr(u, i), Quantity)]
+        dim = getattr(u, quantity)
+        if isinstance(dim, Dimension):
+            rv.extend(find_unit(dim))
+    else:
+        for i in sorted(dir(u)):
+            other = getattr(u, i)
+            if not isinstance(other, Quantity):
+                continue
+            if isinstance(quantity, Quantity):
+                if quantity.dimension == other.dimension:
+                    rv.append(str(i))
+            elif isinstance(quantity, Dimension):
+                if other.dimension == quantity:
+                    rv.append(str(i))
+            elif other.dimension == Dimension(unit_system.get_dimensional_expr(quantity)):
+                rv.append(str(i))
+    return sorted(set(rv), key=lambda x: (len(x), x))
+
+# NOTE: the old units module had additional variables:
+# 'density', 'illuminance', 'resistance'.
+# They were not dimensions, but units (old Unit class).
+
+__all__ = [
+    'Dimension', 'DimensionSystem',
+    'UnitSystem',
+    'convert_to',
+    'Quantity',
+
+    'amount_of_substance', 'acceleration', 'action', 'area',
+    'capacitance', 'charge', 'conductance', 'current', 'energy',
+    'force', 'frequency', 'impedance', 'inductance', 'length',
+    'luminous_intensity', 'magnetic_density',
+    'magnetic_flux', 'mass', 'momentum', 'power', 'pressure', 'temperature', 'time',
+    'velocity', 'voltage', 'volume',
+
+    'Unit',
+
+    'speed',
+    'luminosity',
+    'magnetic_flux_density',
+    'amount',
+
+    'yotta',
+    'zetta',
+    'exa',
+    'peta',
+    'tera',
+    'giga',
+    'mega',
+    'kilo',
+    'hecto',
+    'deca',
+    'deci',
+    'centi',
+    'milli',
+    'micro',
+    'nano',
+    'pico',
+    'femto',
+    'atto',
+    'zepto',
+    'yocto',
+
+    'kibi',
+    'mebi',
+    'gibi',
+    'tebi',
+    'pebi',
+    'exbi',
+
+    'percent', 'percents',
+    'permille',
+    'rad', 'radian', 'radians',
+    'deg', 'degree', 'degrees',
+    'sr', 'steradian', 'steradians',
+    'mil', 'angular_mil', 'angular_mils',
+    'm', 'meter', 'meters',
+    'kg', 'kilogram', 'kilograms',
+    's', 'second', 'seconds',
+    'A', 'ampere', 'amperes',
+    'K', 'kelvin', 'kelvins',
+    'mol', 'mole', 'moles',
+    'cd', 'candela', 'candelas',
+    'g', 'gram', 'grams',
+    'mg', 'milligram', 'milligrams',
+    'ug', 'microgram', 'micrograms',
+    't', 'tonne', 'metric_ton',
+    'newton', 'newtons', 'N',
+    'joule', 'joules', 'J',
+    'watt', 'watts', 'W',
+    'pascal', 'pascals', 'Pa', 'pa',
+    'hertz', 'hz', 'Hz',
+    'coulomb', 'coulombs', 'C',
+    'volt', 'volts', 'v', 'V',
+    'ohm', 'ohms',
+    'siemens', 'S', 'mho', 'mhos',
+    'farad', 'farads', 'F',
+    'henry', 'henrys', 'H',
+    'tesla', 'teslas', 'T',
+    'weber', 'webers', 'Wb', 'wb',
+    'optical_power', 'dioptre', 'D',
+    'lux', 'lx',
+    'katal', 'kat',
+    'gray', 'Gy',
+    'becquerel', 'Bq',
+    'km', 'kilometer', 'kilometers',
+    'dm', 'decimeter', 'decimeters',
+    'cm', 'centimeter', 'centimeters',
+    'mm', 'millimeter', 'millimeters',
+    'um', 'micrometer', 'micrometers', 'micron', 'microns',
+    'nm', 'nanometer', 'nanometers',
+    'pm', 'picometer', 'picometers',
+    'ft', 'foot', 'feet',
+    'inch', 'inches',
+    'yd', 'yard', 'yards',
+    'mi', 'mile', 'miles',
+    'nmi', 'nautical_mile', 'nautical_miles',
+    'angstrom', 'angstroms',
+    'ha', 'hectare',
+    'l', 'L', 'liter', 'liters',
+    'dl', 'dL', 'deciliter', 'deciliters',
+    'cl', 'cL', 'centiliter', 'centiliters',
+    'ml', 'mL', 'milliliter', 'milliliters',
+    'ms', 'millisecond', 'milliseconds',
+    'us', 'microsecond', 'microseconds',
+    'ns', 'nanosecond', 'nanoseconds',
+    'ps', 'picosecond', 'picoseconds',
+    'minute', 'minutes',
+    'h', 'hour', 'hours',
+    'day', 'days',
+    'anomalistic_year', 'anomalistic_years',
+    'sidereal_year', 'sidereal_years',
+    'tropical_year', 'tropical_years',
+    'common_year', 'common_years',
+    'julian_year', 'julian_years',
+    'draconic_year', 'draconic_years',
+    'gaussian_year', 'gaussian_years',
+    'full_moon_cycle', 'full_moon_cycles',
+    'year', 'years',
+    'G', 'gravitational_constant',
+    'c', 'speed_of_light',
+    'elementary_charge',
+    'hbar',
+    'planck',
+    'eV', 'electronvolt', 'electronvolts',
+    'avogadro_number',
+    'avogadro', 'avogadro_constant',
+    'boltzmann', 'boltzmann_constant',
+    'stefan', 'stefan_boltzmann_constant',
+    'R', 'molar_gas_constant',
+    'faraday_constant',
+    'josephson_constant',
+    'von_klitzing_constant',
+    'Da', 'dalton', 'amu', 'amus', 'atomic_mass_unit', 'atomic_mass_constant',
+    'me', 'electron_rest_mass',
+    'gee', 'gees', 'acceleration_due_to_gravity',
+    'u0', 'magnetic_constant', 'vacuum_permeability',
+    'e0', 'electric_constant', 'vacuum_permittivity',
+    'Z0', 'vacuum_impedance',
+    'coulomb_constant', 'electric_force_constant',
+    'atmosphere', 'atmospheres', 'atm',
+    'kPa',
+    'bar', 'bars',
+    'pound', 'pounds',
+    'psi',
+    'dHg0',
+    'mmHg', 'torr',
+    'mmu', 'mmus', 'milli_mass_unit',
+    'quart', 'quarts',
+    'ly', 'lightyear', 'lightyears',
+    'au', 'astronomical_unit', 'astronomical_units',
+    'planck_mass',
+    'planck_time',
+    'planck_temperature',
+    'planck_length',
+    'planck_charge',
+    'planck_area',
+    'planck_volume',
+    'planck_momentum',
+    'planck_energy',
+    'planck_force',
+    'planck_power',
+    'planck_density',
+    'planck_energy_density',
+    'planck_intensity',
+    'planck_angular_frequency',
+    'planck_pressure',
+    'planck_current',
+    'planck_voltage',
+    'planck_impedance',
+    'planck_acceleration',
+    'bit', 'bits',
+    'byte',
+    'kibibyte', 'kibibytes',
+    'mebibyte', 'mebibytes',
+    'gibibyte', 'gibibytes',
+    'tebibyte', 'tebibytes',
+    'pebibyte', 'pebibytes',
+    'exbibyte', 'exbibytes',
+
+    'mks', 'mksa', 'si',
+]

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/definitions/__init__.py

@@ -0,0 +1,265 @@
+from .unit_definitions import (
+    percent, percents,
+    permille,
+    rad, radian, radians,
+    deg, degree, degrees,
+    sr, steradian, steradians,
+    mil, angular_mil, angular_mils,
+    m, meter, meters,
+    kg, kilogram, kilograms,
+    s, second, seconds,
+    A, ampere, amperes,
+    K, kelvin, kelvins,
+    mol, mole, moles,
+    cd, candela, candelas,
+    g, gram, grams,
+    mg, milligram, milligrams,
+    ug, microgram, micrograms,
+    t, tonne, metric_ton,
+    newton, newtons, N,
+    joule, joules, J,
+    watt, watts, W,
+    pascal, pascals, Pa, pa,
+    hertz, hz, Hz,
+    coulomb, coulombs, C,
+    volt, volts, v, V,
+    ohm, ohms,
+    siemens, S, mho, mhos,
+    farad, farads, F,
+    henry, henrys, H,
+    tesla, teslas, T,
+    weber, webers, Wb, wb,
+    optical_power, dioptre, D,
+    lux, lx,
+    katal, kat,
+    gray, Gy,
+    becquerel, Bq,
+    km, kilometer, kilometers,
+    dm, decimeter, decimeters,
+    cm, centimeter, centimeters,
+    mm, millimeter, millimeters,
+    um, micrometer, micrometers, micron, microns,
+    nm, nanometer, nanometers,
+    pm, picometer, picometers,
+    ft, foot, feet,
+    inch, inches,
+    yd, yard, yards,
+    mi, mile, miles,
+    nmi, nautical_mile, nautical_miles,
+    ha, hectare,
+    l, L, liter, liters,
+    dl, dL, deciliter, deciliters,
+    cl, cL, centiliter, centiliters,
+    ml, mL, milliliter, milliliters,
+    ms, millisecond, milliseconds,
+    us, microsecond, microseconds,
+    ns, nanosecond, nanoseconds,
+    ps, picosecond, picoseconds,
+    minute, minutes,
+    h, hour, hours,
+    day, days,
+    anomalistic_year, anomalistic_years,
+    sidereal_year, sidereal_years,
+    tropical_year, tropical_years,
+    common_year, common_years,
+    julian_year, julian_years,
+    draconic_year, draconic_years,
+    gaussian_year, gaussian_years,
+    full_moon_cycle, full_moon_cycles,
+    year, years,
+    G, gravitational_constant,
+    c, speed_of_light,
+    elementary_charge,
+    hbar,
+    planck,
+    eV, electronvolt, electronvolts,
+    avogadro_number,
+    avogadro, avogadro_constant,
+    boltzmann, boltzmann_constant,
+    stefan, stefan_boltzmann_constant,
+    R, molar_gas_constant,
+    faraday_constant,
+    josephson_constant,
+    von_klitzing_constant,
+    Da, dalton, amu, amus, atomic_mass_unit, atomic_mass_constant,
+    me, electron_rest_mass,
+    gee, gees, acceleration_due_to_gravity,
+    u0, magnetic_constant, vacuum_permeability,
+    e0, electric_constant, vacuum_permittivity,
+    Z0, vacuum_impedance,
+    coulomb_constant, coulombs_constant, electric_force_constant,
+    atmosphere, atmospheres, atm,
+    kPa, kilopascal,
+    bar, bars,
+    pound, pounds,
+    psi,
+    dHg0,
+    mmHg, torr,
+    mmu, mmus, milli_mass_unit,
+    quart, quarts,
+    angstrom, angstroms,
+    ly, lightyear, lightyears,
+    au, astronomical_unit, astronomical_units,
+    planck_mass,
+    planck_time,
+    planck_temperature,
+    planck_length,
+    planck_charge,
+    planck_area,
+    planck_volume,
+    planck_momentum,
+    planck_energy,
+    planck_force,
+    planck_power,
+    planck_density,
+    planck_energy_density,
+    planck_intensity,
+    planck_angular_frequency,
+    planck_pressure,
+    planck_current,
+    planck_voltage,
+    planck_impedance,
+    planck_acceleration,
+    bit, bits,
+    byte,
+    kibibyte, kibibytes,
+    mebibyte, mebibytes,
+    gibibyte, gibibytes,
+    tebibyte, tebibytes,
+    pebibyte, pebibytes,
+    exbibyte, exbibytes,
+    curie, rutherford
+)
+
+__all__ = [
+    'percent', 'percents',
+    'permille',
+    'rad', 'radian', 'radians',
+    'deg', 'degree', 'degrees',
+    'sr', 'steradian', 'steradians',
+    'mil', 'angular_mil', 'angular_mils',
+    'm', 'meter', 'meters',
+    'kg', 'kilogram', 'kilograms',
+    's', 'second', 'seconds',
+    'A', 'ampere', 'amperes',
+    'K', 'kelvin', 'kelvins',
+    'mol', 'mole', 'moles',
+    'cd', 'candela', 'candelas',
+    'g', 'gram', 'grams',
+    'mg', 'milligram', 'milligrams',
+    'ug', 'microgram', 'micrograms',
+    't', 'tonne', 'metric_ton',
+    'newton', 'newtons', 'N',
+    'joule', 'joules', 'J',
+    'watt', 'watts', 'W',
+    'pascal', 'pascals', 'Pa', 'pa',
+    'hertz', 'hz', 'Hz',
+    'coulomb', 'coulombs', 'C',
+    'volt', 'volts', 'v', 'V',
+    'ohm', 'ohms',
+    'siemens', 'S', 'mho', 'mhos',
+    'farad', 'farads', 'F',
+    'henry', 'henrys', 'H',
+    'tesla', 'teslas', 'T',
+    'weber', 'webers', 'Wb', 'wb',
+    'optical_power', 'dioptre', 'D',
+    'lux', 'lx',
+    'katal', 'kat',
+    'gray', 'Gy',
+    'becquerel', 'Bq',
+    'km', 'kilometer', 'kilometers',
+    'dm', 'decimeter', 'decimeters',
+    'cm', 'centimeter', 'centimeters',
+    'mm', 'millimeter', 'millimeters',
+    'um', 'micrometer', 'micrometers', 'micron', 'microns',
+    'nm', 'nanometer', 'nanometers',
+    'pm', 'picometer', 'picometers',
+    'ft', 'foot', 'feet',
+    'inch', 'inches',
+    'yd', 'yard', 'yards',
+    'mi', 'mile', 'miles',
+    'nmi', 'nautical_mile', 'nautical_miles',
+    'ha', 'hectare',
+    'l', 'L', 'liter', 'liters',
+    'dl', 'dL', 'deciliter', 'deciliters',
+    'cl', 'cL', 'centiliter', 'centiliters',
+    'ml', 'mL', 'milliliter', 'milliliters',
+    'ms', 'millisecond', 'milliseconds',
+    'us', 'microsecond', 'microseconds',
+    'ns', 'nanosecond', 'nanoseconds',
+    'ps', 'picosecond', 'picoseconds',
+    'minute', 'minutes',
+    'h', 'hour', 'hours',
+    'day', 'days',
+    'anomalistic_year', 'anomalistic_years',
+    'sidereal_year', 'sidereal_years',
+    'tropical_year', 'tropical_years',
+    'common_year', 'common_years',
+    'julian_year', 'julian_years',
+    'draconic_year', 'draconic_years',
+    'gaussian_year', 'gaussian_years',
+    'full_moon_cycle', 'full_moon_cycles',
+    'year', 'years',
+    'G', 'gravitational_constant',
+    'c', 'speed_of_light',
+    'elementary_charge',
+    'hbar',
+    'planck',
+    'eV', 'electronvolt', 'electronvolts',
+    'avogadro_number',
+    'avogadro', 'avogadro_constant',
+    'boltzmann', 'boltzmann_constant',
+    'stefan', 'stefan_boltzmann_constant',
+    'R', 'molar_gas_constant',
+    'faraday_constant',
+    'josephson_constant',
+    'von_klitzing_constant',
+    'Da', 'dalton', 'amu', 'amus', 'atomic_mass_unit', 'atomic_mass_constant',
+    'me', 'electron_rest_mass',
+    'gee', 'gees', 'acceleration_due_to_gravity',
+    'u0', 'magnetic_constant', 'vacuum_permeability',
+    'e0', 'electric_constant', 'vacuum_permittivity',
+    'Z0', 'vacuum_impedance',
+    'coulomb_constant', 'coulombs_constant', 'electric_force_constant',
+    'atmosphere', 'atmospheres', 'atm',
+    'kPa', 'kilopascal',
+    'bar', 'bars',
+    'pound', 'pounds',
+    'psi',
+    'dHg0',
+    'mmHg', 'torr',
+    'mmu', 'mmus', 'milli_mass_unit',
+    'quart', 'quarts',
+    'angstrom', 'angstroms',
+    'ly', 'lightyear', 'lightyears',
+    'au', 'astronomical_unit', 'astronomical_units',
+    'planck_mass',
+    'planck_time',
+    'planck_temperature',
+    'planck_length',
+    'planck_charge',
+    'planck_area',
+    'planck_volume',
+    'planck_momentum',
+    'planck_energy',
+    'planck_force',
+    'planck_power',
+    'planck_density',
+    'planck_energy_density',
+    'planck_intensity',
+    'planck_angular_frequency',
+    'planck_pressure',
+    'planck_current',
+    'planck_voltage',
+    'planck_impedance',
+    'planck_acceleration',
+    'bit', 'bits',
+    'byte',
+    'kibibyte', 'kibibytes',
+    'mebibyte', 'mebibytes',
+    'gibibyte', 'gibibytes',
+    'tebibyte', 'tebibytes',
+    'pebibyte', 'pebibytes',
+    'exbibyte', 'exbibytes',
+    'curie', 'rutherford',
+]

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/definitions/dimension_definitions.py

@@ -0,0 +1,43 @@
+from sympy.physics.units import Dimension
+
+
+angle: Dimension = Dimension(name="angle")
+
+# base dimensions (MKS)
+length = Dimension(name="length", symbol="L")
+mass = Dimension(name="mass", symbol="M")
+time = Dimension(name="time", symbol="T")
+
+# base dimensions (MKSA not in MKS)
+current: Dimension = Dimension(name='current', symbol='I')
+
+# other base dimensions:
+temperature: Dimension = Dimension("temperature", "T")
+amount_of_substance: Dimension = Dimension("amount_of_substance")
+luminous_intensity: Dimension = Dimension("luminous_intensity")
+
+# derived dimensions (MKS)
+velocity = Dimension(name="velocity")
+acceleration = Dimension(name="acceleration")
+momentum = Dimension(name="momentum")
+force = Dimension(name="force", symbol="F")
+energy = Dimension(name="energy", symbol="E")
+power = Dimension(name="power")
+pressure = Dimension(name="pressure")
+frequency = Dimension(name="frequency", symbol="f")
+action = Dimension(name="action", symbol="A")
+area = Dimension("area")
+volume = Dimension("volume")
+
+# derived dimensions (MKSA not in MKS)
+voltage: Dimension = Dimension(name='voltage', symbol='U')
+impedance: Dimension = Dimension(name='impedance', symbol='Z')
+conductance: Dimension = Dimension(name='conductance', symbol='G')
+capacitance: Dimension = Dimension(name='capacitance')
+inductance: Dimension = Dimension(name='inductance')
+charge: Dimension = Dimension(name='charge', symbol='Q')
+magnetic_density: Dimension = Dimension(name='magnetic_density', symbol='B')
+magnetic_flux: Dimension = Dimension(name='magnetic_flux')
+
+# Dimensions in information theory:
+information: Dimension = Dimension(name='information')

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/definitions/unit_definitions.py

@@ -0,0 +1,407 @@
+from sympy.physics.units.definitions.dimension_definitions import current, temperature, amount_of_substance, \
+    luminous_intensity, angle, charge, voltage, impedance, conductance, capacitance, inductance, magnetic_density, \
+    magnetic_flux, information
+
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S as S_singleton
+from sympy.physics.units.prefixes import kilo, mega, milli, micro, deci, centi, nano, pico, kibi, mebi, gibi, tebi, pebi, exbi
+from sympy.physics.units.quantities import PhysicalConstant, Quantity
+
+One = S_singleton.One
+
+#### UNITS ####
+
+# Dimensionless:
+percent = percents = Quantity("percent", latex_repr=r"\%")
+percent.set_global_relative_scale_factor(Rational(1, 100), One)
+
+permille = Quantity("permille")
+permille.set_global_relative_scale_factor(Rational(1, 1000), One)
+
+
+# Angular units (dimensionless)
+rad = radian = radians = Quantity("radian", abbrev="rad")
+radian.set_global_dimension(angle)
+deg = degree = degrees = Quantity("degree", abbrev="deg", latex_repr=r"^\circ")
+degree.set_global_relative_scale_factor(pi/180, radian)
+sr = steradian = steradians = Quantity("steradian", abbrev="sr")
+mil = angular_mil = angular_mils = Quantity("angular_mil", abbrev="mil")
+
+# Base units:
+m = meter = meters = Quantity("meter", abbrev="m")
+
+# gram; used to define its prefixed units
+g = gram = grams = Quantity("gram", abbrev="g")
+
+# NOTE: the `kilogram` has scale factor 1000. In SI, kg is a base unit, but
+# nonetheless we are trying to be compatible with the `kilo` prefix. In a
+# similar manner, people using CGS or gaussian units could argue that the
+# `centimeter` rather than `meter` is the fundamental unit for length, but the
+# scale factor of `centimeter` will be kept as 1/100 to be compatible with the
+# `centi` prefix.  The current state of the code assumes SI unit dimensions, in
+# the future this module will be modified in order to be unit system-neutral
+# (that is, support all kinds of unit systems).
+kg = kilogram = kilograms = Quantity("kilogram", abbrev="kg")
+kg.set_global_relative_scale_factor(kilo, gram)
+
+s = second = seconds = Quantity("second", abbrev="s")
+A = ampere = amperes = Quantity("ampere", abbrev='A')
+ampere.set_global_dimension(current)
+K = kelvin = kelvins = Quantity("kelvin", abbrev='K')
+kelvin.set_global_dimension(temperature)
+mol = mole = moles = Quantity("mole", abbrev="mol")
+mole.set_global_dimension(amount_of_substance)
+cd = candela = candelas = Quantity("candela", abbrev="cd")
+candela.set_global_dimension(luminous_intensity)
+
+# derived units
+newton = newtons = N = Quantity("newton", abbrev="N")
+
+kilonewton = kilonewtons = kN = Quantity("kilonewton", abbrev="kN")
+kilonewton.set_global_relative_scale_factor(kilo, newton)
+
+meganewton = meganewtons = MN = Quantity("meganewton", abbrev="MN")
+meganewton.set_global_relative_scale_factor(mega, newton)
+
+joule = joules = J = Quantity("joule", abbrev="J")
+watt = watts = W = Quantity("watt", abbrev="W")
+pascal = pascals = Pa = pa = Quantity("pascal", abbrev="Pa")
+hertz = hz = Hz = Quantity("hertz", abbrev="Hz")
+
+# CGS derived units:
+dyne = Quantity("dyne")
+dyne.set_global_relative_scale_factor(One/10**5, newton)
+erg = Quantity("erg")
+erg.set_global_relative_scale_factor(One/10**7, joule)
+
+# MKSA extension to MKS: derived units
+coulomb = coulombs = C = Quantity("coulomb", abbrev='C')
+coulomb.set_global_dimension(charge)
+volt = volts = v = V = Quantity("volt", abbrev='V')
+volt.set_global_dimension(voltage)
+ohm = ohms = Quantity("ohm", abbrev='ohm', latex_repr=r"\Omega")
+ohm.set_global_dimension(impedance)
+siemens = S = mho = mhos = Quantity("siemens", abbrev='S')
+siemens.set_global_dimension(conductance)
+farad = farads = F = Quantity("farad", abbrev='F')
+farad.set_global_dimension(capacitance)
+henry = henrys = H = Quantity("henry", abbrev='H')
+henry.set_global_dimension(inductance)
+tesla = teslas = T = Quantity("tesla", abbrev='T')
+tesla.set_global_dimension(magnetic_density)
+weber = webers = Wb = wb = Quantity("weber", abbrev='Wb')
+weber.set_global_dimension(magnetic_flux)
+
+# CGS units for electromagnetic quantities:
+statampere = Quantity("statampere")
+statcoulomb = statC = franklin = Quantity("statcoulomb", abbrev="statC")
+statvolt = Quantity("statvolt")
+gauss = Quantity("gauss")
+maxwell = Quantity("maxwell")
+debye = Quantity("debye")
+oersted = Quantity("oersted")
+
+# Other derived units:
+optical_power = dioptre = diopter = D = Quantity("dioptre")
+lux = lx = Quantity("lux", abbrev="lx")
+
+# katal is the SI unit of catalytic activity
+katal = kat = Quantity("katal", abbrev="kat")
+
+# gray is the SI unit of absorbed dose
+gray = Gy = Quantity("gray")
+
+# becquerel is the SI unit of radioactivity
+becquerel = Bq = Quantity("becquerel", abbrev="Bq")
+
+
+# Common mass units
+
+mg = milligram = milligrams = Quantity("milligram", abbrev="mg")
+mg.set_global_relative_scale_factor(milli, gram)
+
+ug = microgram = micrograms = Quantity("microgram", abbrev="ug", latex_repr=r"\mu\text{g}")
+ug.set_global_relative_scale_factor(micro, gram)
+
+# Atomic mass constant
+Da = dalton = amu = amus = atomic_mass_unit = atomic_mass_constant = PhysicalConstant("atomic_mass_constant")
+
+t = metric_ton = tonne = Quantity("tonne", abbrev="t")
+tonne.set_global_relative_scale_factor(mega, gram)
+
+# Electron rest mass
+me = electron_rest_mass = Quantity("electron_rest_mass", abbrev="me")
+
+
+# Common length units
+
+km = kilometer = kilometers = Quantity("kilometer", abbrev="km")
+km.set_global_relative_scale_factor(kilo, meter)
+
+dm = decimeter = decimeters = Quantity("decimeter", abbrev="dm")
+dm.set_global_relative_scale_factor(deci, meter)
+
+cm = centimeter = centimeters = Quantity("centimeter", abbrev="cm")
+cm.set_global_relative_scale_factor(centi, meter)
+
+mm = millimeter = millimeters = Quantity("millimeter", abbrev="mm")
+mm.set_global_relative_scale_factor(milli, meter)
+
+um = micrometer = micrometers = micron = microns = \
+    Quantity("micrometer", abbrev="um", latex_repr=r'\mu\text{m}')
+um.set_global_relative_scale_factor(micro, meter)
+
+nm = nanometer = nanometers = Quantity("nanometer", abbrev="nm")
+nm.set_global_relative_scale_factor(nano, meter)
+
+pm = picometer = picometers = Quantity("picometer", abbrev="pm")
+pm.set_global_relative_scale_factor(pico, meter)
+
+ft = foot = feet = Quantity("foot", abbrev="ft")
+ft.set_global_relative_scale_factor(Rational(3048, 10000), meter)
+
+inch = inches = Quantity("inch")
+inch.set_global_relative_scale_factor(Rational(1, 12), foot)
+
+yd = yard = yards = Quantity("yard", abbrev="yd")
+yd.set_global_relative_scale_factor(3, feet)
+
+mi = mile = miles = Quantity("mile")
+mi.set_global_relative_scale_factor(5280, feet)
+
+nmi = nautical_mile = nautical_miles = Quantity("nautical_mile")
+nmi.set_global_relative_scale_factor(6076, feet)
+
+angstrom = angstroms = Quantity("angstrom", latex_repr=r'\r{A}')
+angstrom.set_global_relative_scale_factor(Rational(1, 10**10), meter)
+
+
+# Common volume and area units
+
+ha = hectare = Quantity("hectare", abbrev="ha")
+
+l = L = liter = liters = Quantity("liter", abbrev="l")
+
+dl = dL = deciliter = deciliters = Quantity("deciliter", abbrev="dl")
+dl.set_global_relative_scale_factor(Rational(1, 10), liter)
+
+cl = cL = centiliter = centiliters = Quantity("centiliter", abbrev="cl")
+cl.set_global_relative_scale_factor(Rational(1, 100), liter)
+
+ml = mL = milliliter = milliliters = Quantity("milliliter", abbrev="ml")
+ml.set_global_relative_scale_factor(Rational(1, 1000), liter)
+
+
+# Common time units
+
+ms = millisecond = milliseconds = Quantity("millisecond", abbrev="ms")
+millisecond.set_global_relative_scale_factor(milli, second)
+
+us = microsecond = microseconds = Quantity("microsecond", abbrev="us", latex_repr=r'\mu\text{s}')
+microsecond.set_global_relative_scale_factor(micro, second)
+
+ns = nanosecond = nanoseconds = Quantity("nanosecond", abbrev="ns")
+nanosecond.set_global_relative_scale_factor(nano, second)
+
+ps = picosecond = picoseconds = Quantity("picosecond", abbrev="ps")
+picosecond.set_global_relative_scale_factor(pico, second)
+
+minute = minutes = Quantity("minute")
+minute.set_global_relative_scale_factor(60, second)
+
+h = hour = hours = Quantity("hour")
+hour.set_global_relative_scale_factor(60, minute)
+
+day = days = Quantity("day")
+day.set_global_relative_scale_factor(24, hour)
+
+anomalistic_year = anomalistic_years = Quantity("anomalistic_year")
+anomalistic_year.set_global_relative_scale_factor(365.259636, day)
+
+sidereal_year = sidereal_years = Quantity("sidereal_year")
+sidereal_year.set_global_relative_scale_factor(31558149.540, seconds)
+
+tropical_year = tropical_years = Quantity("tropical_year")
+tropical_year.set_global_relative_scale_factor(365.24219, day)
+
+common_year = common_years = Quantity("common_year")
+common_year.set_global_relative_scale_factor(365, day)
+
+julian_year = julian_years = Quantity("julian_year")
+julian_year.set_global_relative_scale_factor((365 + One/4), day)
+
+draconic_year = draconic_years = Quantity("draconic_year")
+draconic_year.set_global_relative_scale_factor(346.62, day)
+
+gaussian_year = gaussian_years = Quantity("gaussian_year")
+gaussian_year.set_global_relative_scale_factor(365.2568983, day)
+
+full_moon_cycle = full_moon_cycles = Quantity("full_moon_cycle")
+full_moon_cycle.set_global_relative_scale_factor(411.78443029, day)
+
+year = years = tropical_year
+
+
+#### CONSTANTS ####
+
+# Newton constant
+G = gravitational_constant = PhysicalConstant("gravitational_constant", abbrev="G")
+
+# speed of light
+c = speed_of_light = PhysicalConstant("speed_of_light", abbrev="c")
+
+# elementary charge
+elementary_charge = PhysicalConstant("elementary_charge", abbrev="e")
+
+# Planck constant
+planck = PhysicalConstant("planck", abbrev="h")
+
+# Reduced Planck constant
+hbar = PhysicalConstant("hbar", abbrev="hbar")
+
+# Electronvolt
+eV = electronvolt = electronvolts = PhysicalConstant("electronvolt", abbrev="eV")
+
+# Avogadro number
+avogadro_number = PhysicalConstant("avogadro_number")
+
+# Avogadro constant
+avogadro = avogadro_constant = PhysicalConstant("avogadro_constant")
+
+# Boltzmann constant
+boltzmann = boltzmann_constant = PhysicalConstant("boltzmann_constant")
+
+# Stefan-Boltzmann constant
+stefan = stefan_boltzmann_constant = PhysicalConstant("stefan_boltzmann_constant")
+
+# Molar gas constant
+R = molar_gas_constant = PhysicalConstant("molar_gas_constant", abbrev="R")
+
+# Faraday constant
+faraday_constant = PhysicalConstant("faraday_constant")
+
+# Josephson constant
+josephson_constant = PhysicalConstant("josephson_constant", abbrev="K_j")
+
+# Von Klitzing constant
+von_klitzing_constant = PhysicalConstant("von_klitzing_constant", abbrev="R_k")
+
+# Acceleration due to gravity (on the Earth surface)
+gee = gees = acceleration_due_to_gravity = PhysicalConstant("acceleration_due_to_gravity", abbrev="g")
+
+# magnetic constant:
+u0 = magnetic_constant = vacuum_permeability = PhysicalConstant("magnetic_constant")
+
+# electric constat:
+e0 = electric_constant = vacuum_permittivity = PhysicalConstant("vacuum_permittivity")
+
+# vacuum impedance:
+Z0 = vacuum_impedance = PhysicalConstant("vacuum_impedance", abbrev='Z_0', latex_repr=r'Z_{0}')
+
+# Coulomb's constant:
+coulomb_constant = coulombs_constant = electric_force_constant = \
+    PhysicalConstant("coulomb_constant", abbrev="k_e")
+
+
+atmosphere = atmospheres = atm = Quantity("atmosphere", abbrev="atm")
+
+kPa = kilopascal = Quantity("kilopascal", abbrev="kPa")
+kilopascal.set_global_relative_scale_factor(kilo, Pa)
+
+bar = bars = Quantity("bar", abbrev="bar")
+
+pound = pounds = Quantity("pound")  # exact
+
+psi = Quantity("psi")
+
+dHg0 = 13.5951  # approx value at 0 C
+mmHg = torr = Quantity("mmHg")
+
+atmosphere.set_global_relative_scale_factor(101325, pascal)
+bar.set_global_relative_scale_factor(100, kPa)
+pound.set_global_relative_scale_factor(Rational(45359237, 100000000), kg)
+
+mmu = mmus = milli_mass_unit = Quantity("milli_mass_unit")
+
+quart = quarts = Quantity("quart")
+
+
+# Other convenient units and magnitudes
+
+ly = lightyear = lightyears = Quantity("lightyear", abbrev="ly")
+
+au = astronomical_unit = astronomical_units = Quantity("astronomical_unit", abbrev="AU")
+
+
+# Fundamental Planck units:
+planck_mass = Quantity("planck_mass", abbrev="m_P", latex_repr=r'm_\text{P}')
+
+planck_time = Quantity("planck_time", abbrev="t_P", latex_repr=r't_\text{P}')
+
+planck_temperature = Quantity("planck_temperature", abbrev="T_P",
+                              latex_repr=r'T_\text{P}')
+
+planck_length = Quantity("planck_length", abbrev="l_P", latex_repr=r'l_\text{P}')
+
+planck_charge = Quantity("planck_charge", abbrev="q_P", latex_repr=r'q_\text{P}')
+
+
+# Derived Planck units:
+planck_area = Quantity("planck_area")
+
+planck_volume = Quantity("planck_volume")
+
+planck_momentum = Quantity("planck_momentum")
+
+planck_energy = Quantity("planck_energy", abbrev="E_P", latex_repr=r'E_\text{P}')
+
+planck_force = Quantity("planck_force", abbrev="F_P", latex_repr=r'F_\text{P}')
+
+planck_power = Quantity("planck_power", abbrev="P_P", latex_repr=r'P_\text{P}')
+
+planck_density = Quantity("planck_density", abbrev="rho_P", latex_repr=r'\rho_\text{P}')
+
+planck_energy_density = Quantity("planck_energy_density", abbrev="rho^E_P")
+
+planck_intensity = Quantity("planck_intensity", abbrev="I_P", latex_repr=r'I_\text{P}')
+
+planck_angular_frequency = Quantity("planck_angular_frequency", abbrev="omega_P",
+                                    latex_repr=r'\omega_\text{P}')
+
+planck_pressure = Quantity("planck_pressure", abbrev="p_P", latex_repr=r'p_\text{P}')
+
+planck_current = Quantity("planck_current", abbrev="I_P", latex_repr=r'I_\text{P}')
+
+planck_voltage = Quantity("planck_voltage", abbrev="V_P", latex_repr=r'V_\text{P}')
+
+planck_impedance = Quantity("planck_impedance", abbrev="Z_P", latex_repr=r'Z_\text{P}')
+
+planck_acceleration = Quantity("planck_acceleration", abbrev="a_P",
+                               latex_repr=r'a_\text{P}')
+
+
+# Information theory units:
+bit = bits = Quantity("bit")
+bit.set_global_dimension(information)
+
+byte = bytes = Quantity("byte")
+
+kibibyte = kibibytes = Quantity("kibibyte")
+mebibyte = mebibytes = Quantity("mebibyte")
+gibibyte = gibibytes = Quantity("gibibyte")
+tebibyte = tebibytes = Quantity("tebibyte")
+pebibyte = pebibytes = Quantity("pebibyte")
+exbibyte = exbibytes = Quantity("exbibyte")
+
+byte.set_global_relative_scale_factor(8, bit)
+kibibyte.set_global_relative_scale_factor(kibi, byte)
+mebibyte.set_global_relative_scale_factor(mebi, byte)
+gibibyte.set_global_relative_scale_factor(gibi, byte)
+tebibyte.set_global_relative_scale_factor(tebi, byte)
+pebibyte.set_global_relative_scale_factor(pebi, byte)
+exbibyte.set_global_relative_scale_factor(exbi, byte)
+
+# Older units for radioactivity
+curie = Ci = Quantity("curie", abbrev="Ci")
+
+rutherford = Rd = Quantity("rutherford", abbrev="Rd")

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/dimensions.py

@@ -0,0 +1,590 @@
+"""
+Definition of physical dimensions.
+
+Unit systems will be constructed on top of these dimensions.
+
+Most of the examples in the doc use MKS system and are presented from the
+computer point of view: from a human point, adding length to time is not legal
+in MKS but it is in natural system; for a computer in natural system there is
+no time dimension (but a velocity dimension instead) - in the basis - so the
+question of adding time to length has no meaning.
+"""
+
+from __future__ import annotations
+
+import collections
+from functools import reduce
+
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.matrices.dense import Matrix
+from sympy.functions.elementary.trigonometric import TrigonometricFunction
+from sympy.core.expr import Expr
+from sympy.core.power import Pow
+
+
+class _QuantityMapper:
+
+    _quantity_scale_factors_global: dict[Expr, Expr] = {}
+    _quantity_dimensional_equivalence_map_global: dict[Expr, Expr] = {}
+    _quantity_dimension_global: dict[Expr, Expr] = {}
+
+    def __init__(self, *args, **kwargs):
+        self._quantity_dimension_map = {}
+        self._quantity_scale_factors = {}
+
+    def set_quantity_dimension(self, quantity, dimension):
+        """
+        Set the dimension for the quantity in a unit system.
+
+        If this relation is valid in every unit system, use
+        ``quantity.set_global_dimension(dimension)`` instead.
+        """
+        from sympy.physics.units import Quantity
+        dimension = sympify(dimension)
+        if not isinstance(dimension, Dimension):
+            if dimension == 1:
+                dimension = Dimension(1)
+            else:
+                raise ValueError("expected dimension or 1")
+        elif isinstance(dimension, Quantity):
+            dimension = self.get_quantity_dimension(dimension)
+        self._quantity_dimension_map[quantity] = dimension
+
+    def set_quantity_scale_factor(self, quantity, scale_factor):
+        """
+        Set the scale factor of a quantity relative to another quantity.
+
+        It should be used only once per quantity to just one other quantity,
+        the algorithm will then be able to compute the scale factors to all
+        other quantities.
+
+        In case the scale factor is valid in every unit system, please use
+        ``quantity.set_global_relative_scale_factor(scale_factor)`` instead.
+        """
+        from sympy.physics.units import Quantity
+        from sympy.physics.units.prefixes import Prefix
+        scale_factor = sympify(scale_factor)
+        # replace all prefixes by their ratio to canonical units:
+        scale_factor = scale_factor.replace(
+            lambda x: isinstance(x, Prefix),
+            lambda x: x.scale_factor
+        )
+        # replace all quantities by their ratio to canonical units:
+        scale_factor = scale_factor.replace(
+            lambda x: isinstance(x, Quantity),
+            lambda x: self.get_quantity_scale_factor(x)
+        )
+        self._quantity_scale_factors[quantity] = scale_factor
+
+    def get_quantity_dimension(self, unit):
+        from sympy.physics.units import Quantity
+        # First look-up the local dimension map, then the global one:
+        if unit in self._quantity_dimension_map:
+            return self._quantity_dimension_map[unit]
+        if unit in self._quantity_dimension_global:
+            return self._quantity_dimension_global[unit]
+        if unit in self._quantity_dimensional_equivalence_map_global:
+            dep_unit = self._quantity_dimensional_equivalence_map_global[unit]
+            if isinstance(dep_unit, Quantity):
+                return self.get_quantity_dimension(dep_unit)
+            else:
+                return Dimension(self.get_dimensional_expr(dep_unit))
+        if isinstance(unit, Quantity):
+            return Dimension(unit.name)
+        else:
+            return Dimension(1)
+
+    def get_quantity_scale_factor(self, unit):
+        if unit in self._quantity_scale_factors:
+            return self._quantity_scale_factors[unit]
+        if unit in self._quantity_scale_factors_global:
+            mul_factor, other_unit = self._quantity_scale_factors_global[unit]
+            return mul_factor*self.get_quantity_scale_factor(other_unit)
+        return S.One
+
+
+class Dimension(Expr):
+    """
+    This class represent the dimension of a physical quantities.
+
+    The ``Dimension`` constructor takes as parameters a name and an optional
+    symbol.
+
+    For example, in classical mechanics we know that time is different from
+    temperature and dimensions make this difference (but they do not provide
+    any measure of these quantities.
+
+        >>> from sympy.physics.units import Dimension
+        >>> length = Dimension('length')
+        >>> length
+        Dimension(length)
+        >>> time = Dimension('time')
+        >>> time
+        Dimension(time)
+
+    Dimensions can be composed using multiplication, division and
+    exponentiation (by a number) to give new dimensions. Addition and
+    subtraction is defined only when the two objects are the same dimension.
+
+        >>> velocity = length / time
+        >>> velocity
+        Dimension(length/time)
+
+    It is possible to use a dimension system object to get the dimensionsal
+    dependencies of a dimension, for example the dimension system used by the
+    SI units convention can be used:
+
+        >>> from sympy.physics.units.systems.si import dimsys_SI
+        >>> dimsys_SI.get_dimensional_dependencies(velocity)
+        {Dimension(length, L): 1, Dimension(time, T): -1}
+        >>> length + length
+        Dimension(length)
+        >>> l2 = length**2
+        >>> l2
+        Dimension(length**2)
+        >>> dimsys_SI.get_dimensional_dependencies(l2)
+        {Dimension(length, L): 2}
+
+    """
+
+    _op_priority = 13.0
+
+    # XXX: This doesn't seem to be used anywhere...
+    _dimensional_dependencies = {}  # type: ignore
+
+    is_commutative = True
+    is_number = False
+    # make sqrt(M**2) --> M
+    is_positive = True
+    is_real = True
+
+    def __new__(cls, name, symbol=None):
+
+        if isinstance(name, str):
+            name = Symbol(name)
+        else:
+            name = sympify(name)
+
+        if not isinstance(name, Expr):
+            raise TypeError("Dimension name needs to be a valid math expression")
+
+        if isinstance(symbol, str):
+            symbol = Symbol(symbol)
+        elif symbol is not None:
+            assert isinstance(symbol, Symbol)
+
+        obj = Expr.__new__(cls, name)
+
+        obj._name = name
+        obj._symbol = symbol
+        return obj
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def symbol(self):
+        return self._symbol
+
+    def __str__(self):
+        """
+        Display the string representation of the dimension.
+        """
+        if self.symbol is None:
+            return "Dimension(%s)" % (self.name)
+        else:
+            return "Dimension(%s, %s)" % (self.name, self.symbol)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __neg__(self):
+        return self
+
+    def __add__(self, other):
+        from sympy.physics.units.quantities import Quantity
+        other = sympify(other)
+        if isinstance(other, Basic):
+            if other.has(Quantity):
+                raise TypeError("cannot sum dimension and quantity")
+            if isinstance(other, Dimension) and self == other:
+                return self
+            return super().__add__(other)
+        return self
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __sub__(self, other):
+        # there is no notion of ordering (or magnitude) among dimension,
+        # subtraction is equivalent to addition when the operation is legal
+        return self + other
+
+    def __rsub__(self, other):
+        # there is no notion of ordering (or magnitude) among dimension,
+        # subtraction is equivalent to addition when the operation is legal
+        return self + other
+
+    def __pow__(self, other):
+        return self._eval_power(other)
+
+    def _eval_power(self, other):
+        other = sympify(other)
+        return Dimension(self.name**other)
+
+    def __mul__(self, other):
+        from sympy.physics.units.quantities import Quantity
+        if isinstance(other, Basic):
+            if other.has(Quantity):
+                raise TypeError("cannot sum dimension and quantity")
+            if isinstance(other, Dimension):
+                return Dimension(self.name*other.name)
+            if not other.free_symbols:  # other.is_number cannot be used
+                return self
+            return super().__mul__(other)
+        return self
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __truediv__(self, other):
+        return self*Pow(other, -1)
+
+    def __rtruediv__(self, other):
+        return other * pow(self, -1)
+
+    @classmethod
+    def _from_dimensional_dependencies(cls, dependencies):
+        return reduce(lambda x, y: x * y, (
+            d**e for d, e in dependencies.items()
+        ), 1)
+
+    def has_integer_powers(self, dim_sys):
+        """
+        Check if the dimension object has only integer powers.
+
+        All the dimension powers should be integers, but rational powers may
+        appear in intermediate steps. This method may be used to check that the
+        final result is well-defined.
+        """
+
+        return all(dpow.is_Integer for dpow in dim_sys.get_dimensional_dependencies(self).values())
+
+
+# Create dimensions according to the base units in MKSA.
+# For other unit systems, they can be derived by transforming the base
+# dimensional dependency dictionary.
+
+
+class DimensionSystem(Basic, _QuantityMapper):
+    r"""
+    DimensionSystem represents a coherent set of dimensions.
+
+    The constructor takes three parameters:
+
+    - base dimensions;
+    - derived dimensions: these are defined in terms of the base dimensions
+      (for example velocity is defined from the division of length by time);
+    - dependency of dimensions: how the derived dimensions depend
+      on the base dimensions.
+
+    Optionally either the ``derived_dims`` or the ``dimensional_dependencies``
+    may be omitted.
+    """
+
+    def __new__(cls, base_dims, derived_dims=(), dimensional_dependencies={}):
+        dimensional_dependencies = dict(dimensional_dependencies)
+
+        def parse_dim(dim):
+            if isinstance(dim, str):
+                dim = Dimension(Symbol(dim))
+            elif isinstance(dim, Dimension):
+                pass
+            elif isinstance(dim, Symbol):
+                dim = Dimension(dim)
+            else:
+                raise TypeError("%s wrong type" % dim)
+            return dim
+
+        base_dims = [parse_dim(i) for i in base_dims]
+        derived_dims = [parse_dim(i) for i in derived_dims]
+
+        for dim in base_dims:
+            if (dim in dimensional_dependencies
+                and (len(dimensional_dependencies[dim]) != 1 or
+                dimensional_dependencies[dim].get(dim, None) != 1)):
+                raise IndexError("Repeated value in base dimensions")
+            dimensional_dependencies[dim] = Dict({dim: 1})
+
+        def parse_dim_name(dim):
+            if isinstance(dim, Dimension):
+                return dim
+            elif isinstance(dim, str):
+                return Dimension(Symbol(dim))
+            elif isinstance(dim, Symbol):
+                return Dimension(dim)
+            else:
+                raise TypeError("unrecognized type %s for %s" % (type(dim), dim))
+
+        for dim in dimensional_dependencies.keys():
+            dim = parse_dim(dim)
+            if (dim not in derived_dims) and (dim not in base_dims):
+                derived_dims.append(dim)
+
+        def parse_dict(d):
+            return Dict({parse_dim_name(i): j for i, j in d.items()})
+
+        # Make sure everything is a SymPy type:
+        dimensional_dependencies = {parse_dim_name(i): parse_dict(j) for i, j in
+                                    dimensional_dependencies.items()}
+
+        for dim in derived_dims:
+            if dim in base_dims:
+                raise ValueError("Dimension %s both in base and derived" % dim)
+            if dim not in dimensional_dependencies:
+                # TODO: should this raise a warning?
+                dimensional_dependencies[dim] = Dict({dim: 1})
+
+        base_dims.sort(key=default_sort_key)
+        derived_dims.sort(key=default_sort_key)
+
+        base_dims = Tuple(*base_dims)
+        derived_dims = Tuple(*derived_dims)
+        dimensional_dependencies = Dict({i: Dict(j) for i, j in dimensional_dependencies.items()})
+        obj = Basic.__new__(cls, base_dims, derived_dims, dimensional_dependencies)
+        return obj
+
+    @property
+    def base_dims(self):
+        return self.args[0]
+
+    @property
+    def derived_dims(self):
+        return self.args[1]
+
+    @property
+    def dimensional_dependencies(self):
+        return self.args[2]
+
+    def _get_dimensional_dependencies_for_name(self, dimension):
+        if isinstance(dimension, str):
+            dimension = Dimension(Symbol(dimension))
+        elif not isinstance(dimension, Dimension):
+            dimension = Dimension(dimension)
+
+        if dimension.name.is_Symbol:
+            # Dimensions not included in the dependencies are considered
+            # as base dimensions:
+            return dict(self.dimensional_dependencies.get(dimension, {dimension: 1}))
+
+        if dimension.name.is_number or dimension.name.is_NumberSymbol:
+            return {}
+
+        get_for_name = self._get_dimensional_dependencies_for_name
+
+        if dimension.name.is_Mul:
+            ret = collections.defaultdict(int)
+            dicts = [get_for_name(i) for i in dimension.name.args]
+            for d in dicts:
+                for k, v in d.items():
+                    ret[k] += v
+            return {k: v for (k, v) in ret.items() if v != 0}
+
+        if dimension.name.is_Add:
+            dicts = [get_for_name(i) for i in dimension.name.args]
+            if all(d == dicts[0] for d in dicts[1:]):
+                return dicts[0]
+            raise TypeError("Only equivalent dimensions can be added or subtracted.")
+
+        if dimension.name.is_Pow:
+            dim_base = get_for_name(dimension.name.base)
+            dim_exp = get_for_name(dimension.name.exp)
+            if dim_exp == {} or dimension.name.exp.is_Symbol:
+                return {k: v * dimension.name.exp for (k, v) in dim_base.items()}
+            else:
+                raise TypeError("The exponent for the power operator must be a Symbol or dimensionless.")
+
+        if dimension.name.is_Function:
+            args = (Dimension._from_dimensional_dependencies(
+                get_for_name(arg)) for arg in dimension.name.args)
+            result = dimension.name.func(*args)
+
+            dicts = [get_for_name(i) for i in dimension.name.args]
+
+            if isinstance(result, Dimension):
+                return self.get_dimensional_dependencies(result)
+            elif result.func == dimension.name.func:
+                if isinstance(dimension.name, TrigonometricFunction):
+                    if dicts[0] in ({}, {Dimension('angle'): 1}):
+                        return {}
+                    else:
+                        raise TypeError("The input argument for the function {} must be dimensionless or have dimensions of angle.".format(dimension.func))
+                else:
+                    if all(item == {} for item in dicts):
+                        return {}
+                    else:
+                        raise TypeError("The input arguments for the function {} must be dimensionless.".format(dimension.func))
+            else:
+                return get_for_name(result)
+
+        raise TypeError("Type {} not implemented for get_dimensional_dependencies".format(type(dimension.name)))
+
+    def get_dimensional_dependencies(self, name, mark_dimensionless=False):
+        dimdep = self._get_dimensional_dependencies_for_name(name)
+        if mark_dimensionless and dimdep == {}:
+            return {Dimension(1): 1}
+        return dict(dimdep.items())
+
+    def equivalent_dims(self, dim1, dim2):
+        deps1 = self.get_dimensional_dependencies(dim1)
+        deps2 = self.get_dimensional_dependencies(dim2)
+        return deps1 == deps2
+
+    def extend(self, new_base_dims, new_derived_dims=(), new_dim_deps=None):
+        deps = dict(self.dimensional_dependencies)
+        if new_dim_deps:
+            deps.update(new_dim_deps)
+
+        new_dim_sys = DimensionSystem(
+            tuple(self.base_dims) + tuple(new_base_dims),
+            tuple(self.derived_dims) + tuple(new_derived_dims),
+            deps
+        )
+        new_dim_sys._quantity_dimension_map.update(self._quantity_dimension_map)
+        new_dim_sys._quantity_scale_factors.update(self._quantity_scale_factors)
+        return new_dim_sys
+
+    def is_dimensionless(self, dimension):
+        """
+        Check if the dimension object really has a dimension.
+
+        A dimension should have at least one component with non-zero power.
+        """
+        if dimension.name == 1:
+            return True
+        return self.get_dimensional_dependencies(dimension) == {}
+
+    @property
+    def list_can_dims(self):
+        """
+        Useless method, kept for compatibility with previous versions.
+
+        DO NOT USE.
+
+        List all canonical dimension names.
+        """
+        dimset = set()
+        for i in self.base_dims:
+            dimset.update(set(self.get_dimensional_dependencies(i).keys()))
+        return tuple(sorted(dimset, key=str))
+
+    @property
+    def inv_can_transf_matrix(self):
+        """
+        Useless method, kept for compatibility with previous versions.
+
+        DO NOT USE.
+
+        Compute the inverse transformation matrix from the base to the
+        canonical dimension basis.
+
+        It corresponds to the matrix where columns are the vector of base
+        dimensions in canonical basis.
+
+        This matrix will almost never be used because dimensions are always
+        defined with respect to the canonical basis, so no work has to be done
+        to get them in this basis. Nonetheless if this matrix is not square
+        (or not invertible) it means that we have chosen a bad basis.
+        """
+        matrix = reduce(lambda x, y: x.row_join(y),
+                        [self.dim_can_vector(d) for d in self.base_dims])
+        return matrix
+
+    @property
+    def can_transf_matrix(self):
+        """
+        Useless method, kept for compatibility with previous versions.
+
+        DO NOT USE.
+
+        Return the canonical transformation matrix from the canonical to the
+        base dimension basis.
+
+        It is the inverse of the matrix computed with inv_can_transf_matrix().
+        """
+
+        #TODO: the inversion will fail if the system is inconsistent, for
+        #      example if the matrix is not a square
+        return reduce(lambda x, y: x.row_join(y),
+                      [self.dim_can_vector(d) for d in sorted(self.base_dims, key=str)]
+                      ).inv()
+
+    def dim_can_vector(self, dim):
+        """
+        Useless method, kept for compatibility with previous versions.
+
+        DO NOT USE.
+
+        Dimensional representation in terms of the canonical base dimensions.
+        """
+
+        vec = []
+        for d in self.list_can_dims:
+            vec.append(self.get_dimensional_dependencies(dim).get(d, 0))
+        return Matrix(vec)
+
+    def dim_vector(self, dim):
+        """
+        Useless method, kept for compatibility with previous versions.
+
+        DO NOT USE.
+
+
+        Vector representation in terms of the base dimensions.
+        """
+        return self.can_transf_matrix * Matrix(self.dim_can_vector(dim))
+
+    def print_dim_base(self, dim):
+        """
+        Give the string expression of a dimension in term of the basis symbols.
+        """
+        dims = self.dim_vector(dim)
+        symbols = [i.symbol if i.symbol is not None else i.name for i in self.base_dims]
+        res = S.One
+        for (s, p) in zip(symbols, dims):
+            res *= s**p
+        return res
+
+    @property
+    def dim(self):
+        """
+        Useless method, kept for compatibility with previous versions.
+
+        DO NOT USE.
+
+        Give the dimension of the system.
+
+        That is return the number of dimensions forming the basis.
+        """
+        return len(self.base_dims)
+
+    @property
+    def is_consistent(self):
+        """
+        Useless method, kept for compatibility with previous versions.
+
+        DO NOT USE.
+
+        Check if the system is well defined.
+        """
+
+        # not enough or too many base dimensions compared to independent
+        # dimensions
+        # in vector language: the set of vectors do not form a basis
+        return self.inv_can_transf_matrix.is_square

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/prefixes.py

@@ -0,0 +1,219 @@
+"""
+Module defining unit prefixe class and some constants.
+
+Constant dict for SI and binary prefixes are defined as PREFIXES and
+BIN_PREFIXES.
+"""
+from sympy.core.expr import Expr
+from sympy.core.sympify import sympify
+from sympy.core.singleton import S
+
+class Prefix(Expr):
+    """
+    This class represent prefixes, with their name, symbol and factor.
+
+    Prefixes are used to create derived units from a given unit. They should
+    always be encapsulated into units.
+
+    The factor is constructed from a base (default is 10) to some power, and
+    it gives the total multiple or fraction. For example the kilometer km
+    is constructed from the meter (factor 1) and the kilo (10 to the power 3,
+    i.e. 1000). The base can be changed to allow e.g. binary prefixes.
+
+    A prefix multiplied by something will always return the product of this
+    other object times the factor, except if the other object:
+
+    - is a prefix and they can be combined into a new prefix;
+    - defines multiplication with prefixes (which is the case for the Unit
+      class).
+    """
+    _op_priority = 13.0
+    is_commutative = True
+
+    def __new__(cls, name, abbrev, exponent, base=sympify(10), latex_repr=None):
+
+        name = sympify(name)
+        abbrev = sympify(abbrev)
+        exponent = sympify(exponent)
+        base = sympify(base)
+
+        obj = Expr.__new__(cls, name, abbrev, exponent, base)
+        obj._name = name
+        obj._abbrev = abbrev
+        obj._scale_factor = base**exponent
+        obj._exponent = exponent
+        obj._base = base
+        obj._latex_repr = latex_repr
+        return obj
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def abbrev(self):
+        return self._abbrev
+
+    @property
+    def scale_factor(self):
+        return self._scale_factor
+
+    def _latex(self, printer):
+        if self._latex_repr is None:
+            return r'\text{%s}' % self._abbrev
+        return self._latex_repr
+
+    @property
+    def base(self):
+        return self._base
+
+    def __str__(self):
+        return str(self._abbrev)
+
+    def __repr__(self):
+        if self.base == 10:
+            return "Prefix(%r, %r, %r)" % (
+                str(self.name), str(self.abbrev), self._exponent)
+        else:
+            return "Prefix(%r, %r, %r, %r)" % (
+                str(self.name), str(self.abbrev), self._exponent, self.base)
+
+    def __mul__(self, other):
+        from sympy.physics.units import Quantity
+        if not isinstance(other, (Quantity, Prefix)):
+            return super().__mul__(other)
+
+        fact = self.scale_factor * other.scale_factor
+
+        if isinstance(other, Prefix):
+            if fact == 1:
+                return S.One
+            # simplify prefix
+            for p in PREFIXES:
+                if PREFIXES[p].scale_factor == fact:
+                    return PREFIXES[p]
+            return fact
+
+        return self.scale_factor * other
+
+    def __truediv__(self, other):
+        if not hasattr(other, "scale_factor"):
+            return super().__truediv__(other)
+
+        fact = self.scale_factor / other.scale_factor
+
+        if fact == 1:
+            return S.One
+        elif isinstance(other, Prefix):
+            for p in PREFIXES:
+                if PREFIXES[p].scale_factor == fact:
+                    return PREFIXES[p]
+            return fact
+
+        return self.scale_factor / other
+
+    def __rtruediv__(self, other):
+        if other == 1:
+            for p in PREFIXES:
+                if PREFIXES[p].scale_factor == 1 / self.scale_factor:
+                    return PREFIXES[p]
+        return other / self.scale_factor
+
+
+def prefix_unit(unit, prefixes):
+    """
+    Return a list of all units formed by unit and the given prefixes.
+
+    You can use the predefined PREFIXES or BIN_PREFIXES, but you can also
+    pass as argument a subdict of them if you do not want all prefixed units.
+
+        >>> from sympy.physics.units.prefixes import (PREFIXES,
+        ...                                                 prefix_unit)
+        >>> from sympy.physics.units import m
+        >>> pref = {"m": PREFIXES["m"], "c": PREFIXES["c"], "d": PREFIXES["d"]}
+        >>> prefix_unit(m, pref)  # doctest: +SKIP
+        [millimeter, centimeter, decimeter]
+    """
+
+    from sympy.physics.units.quantities import Quantity
+    from sympy.physics.units import UnitSystem
+
+    prefixed_units = []
+
+    for prefix in prefixes.values():
+        quantity = Quantity(
+                "%s%s" % (prefix.name, unit.name),
+                abbrev=("%s%s" % (prefix.abbrev, unit.abbrev)),
+                is_prefixed=True,
+           )
+        UnitSystem._quantity_dimensional_equivalence_map_global[quantity] = unit
+        UnitSystem._quantity_scale_factors_global[quantity] = (prefix.scale_factor, unit)
+        prefixed_units.append(quantity)
+
+    return prefixed_units
+
+
+yotta = Prefix('yotta', 'Y', 24)
+zetta = Prefix('zetta', 'Z', 21)
+exa = Prefix('exa', 'E', 18)
+peta = Prefix('peta', 'P', 15)
+tera = Prefix('tera', 'T', 12)
+giga = Prefix('giga', 'G', 9)
+mega = Prefix('mega', 'M', 6)
+kilo = Prefix('kilo', 'k', 3)
+hecto = Prefix('hecto', 'h', 2)
+deca = Prefix('deca', 'da', 1)
+deci = Prefix('deci', 'd', -1)
+centi = Prefix('centi', 'c', -2)
+milli = Prefix('milli', 'm', -3)
+micro = Prefix('micro', 'mu', -6, latex_repr=r"\mu")
+nano = Prefix('nano', 'n', -9)
+pico = Prefix('pico', 'p', -12)
+femto = Prefix('femto', 'f', -15)
+atto = Prefix('atto', 'a', -18)
+zepto = Prefix('zepto', 'z', -21)
+yocto = Prefix('yocto', 'y', -24)
+
+
+# https://physics.nist.gov/cuu/Units/prefixes.html
+PREFIXES = {
+    'Y': yotta,
+    'Z': zetta,
+    'E': exa,
+    'P': peta,
+    'T': tera,
+    'G': giga,
+    'M': mega,
+    'k': kilo,
+    'h': hecto,
+    'da': deca,
+    'd': deci,
+    'c': centi,
+    'm': milli,
+    'mu': micro,
+    'n': nano,
+    'p': pico,
+    'f': femto,
+    'a': atto,
+    'z': zepto,
+    'y': yocto,
+}
+
+
+kibi = Prefix('kibi', 'Y', 10, 2)
+mebi = Prefix('mebi', 'Y', 20, 2)
+gibi = Prefix('gibi', 'Y', 30, 2)
+tebi = Prefix('tebi', 'Y', 40, 2)
+pebi = Prefix('pebi', 'Y', 50, 2)
+exbi = Prefix('exbi', 'Y', 60, 2)
+
+
+# https://physics.nist.gov/cuu/Units/binary.html
+BIN_PREFIXES = {
+    'Ki': kibi,
+    'Mi': mebi,
+    'Gi': gibi,
+    'Ti': tebi,
+    'Pi': pebi,
+    'Ei': exbi,
+}

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/quantities.py

@@ -0,0 +1,152 @@
+"""
+Physical quantities.
+"""
+
+from sympy.core.expr import AtomicExpr
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.physics.units.dimensions import _QuantityMapper
+from sympy.physics.units.prefixes import Prefix
+
+
+class Quantity(AtomicExpr):
+    """
+    Physical quantity: can be a unit of measure, a constant or a generic quantity.
+    """
+
+    is_commutative = True
+    is_real = True
+    is_number = False
+    is_nonzero = True
+    is_physical_constant = False
+    _diff_wrt = True
+
+    def __new__(cls, name, abbrev=None,
+                latex_repr=None, pretty_unicode_repr=None,
+                pretty_ascii_repr=None, mathml_presentation_repr=None,
+                is_prefixed=False,
+                **assumptions):
+
+        if not isinstance(name, Symbol):
+            name = Symbol(name)
+
+        if abbrev is None:
+            abbrev = name
+        elif isinstance(abbrev, str):
+            abbrev = Symbol(abbrev)
+
+        # HACK: These are here purely for type checking. They actually get assigned below.
+        cls._is_prefixed = is_prefixed
+
+        obj = AtomicExpr.__new__(cls, name, abbrev)
+        obj._name = name
+        obj._abbrev = abbrev
+        obj._latex_repr = latex_repr
+        obj._unicode_repr = pretty_unicode_repr
+        obj._ascii_repr = pretty_ascii_repr
+        obj._mathml_repr = mathml_presentation_repr
+        obj._is_prefixed = is_prefixed
+        return obj
+
+    def set_global_dimension(self, dimension):
+        _QuantityMapper._quantity_dimension_global[self] = dimension
+
+    def set_global_relative_scale_factor(self, scale_factor, reference_quantity):
+        """
+        Setting a scale factor that is valid across all unit system.
+        """
+        from sympy.physics.units import UnitSystem
+        scale_factor = sympify(scale_factor)
+        if isinstance(scale_factor, Prefix):
+            self._is_prefixed = True
+        # replace all prefixes by their ratio to canonical units:
+        scale_factor = scale_factor.replace(
+            lambda x: isinstance(x, Prefix),
+            lambda x: x.scale_factor
+        )
+        scale_factor = sympify(scale_factor)
+        UnitSystem._quantity_scale_factors_global[self] = (scale_factor, reference_quantity)
+        UnitSystem._quantity_dimensional_equivalence_map_global[self] = reference_quantity
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def dimension(self):
+        from sympy.physics.units import UnitSystem
+        unit_system = UnitSystem.get_default_unit_system()
+        return unit_system.get_quantity_dimension(self)
+
+    @property
+    def abbrev(self):
+        """
+        Symbol representing the unit name.
+
+        Prepend the abbreviation with the prefix symbol if it is defines.
+        """
+        return self._abbrev
+
+    @property
+    def scale_factor(self):
+        """
+        Overall magnitude of the quantity as compared to the canonical units.
+        """
+        from sympy.physics.units import UnitSystem
+        unit_system = UnitSystem.get_default_unit_system()
+        return unit_system.get_quantity_scale_factor(self)
+
+    def _eval_is_positive(self):
+        return True
+
+    def _eval_is_constant(self):
+        return True
+
+    def _eval_Abs(self):
+        return self
+
+    def _eval_subs(self, old, new):
+        if isinstance(new, Quantity) and self != old:
+            return self
+
+    def _latex(self, printer):
+        if self._latex_repr:
+            return self._latex_repr
+        else:
+            return r'\text{{{}}}'.format(self.args[1] \
+                          if len(self.args) >= 2 else self.args[0])
+
+    def convert_to(self, other, unit_system="SI"):
+        """
+        Convert the quantity to another quantity of same dimensions.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.units import speed_of_light, meter, second
+        >>> speed_of_light
+        speed_of_light
+        >>> speed_of_light.convert_to(meter/second)
+        299792458*meter/second
+
+        >>> from sympy.physics.units import liter
+        >>> liter.convert_to(meter**3)
+        meter**3/1000
+        """
+        from .util import convert_to
+        return convert_to(self, other, unit_system)
+
+    @property
+    def free_symbols(self):
+        """Return free symbols from quantity."""
+        return set()
+
+    @property
+    def is_prefixed(self):
+        """Whether or not the quantity is prefixed. Eg. `kilogram` is prefixed, but `gram` is not."""
+        return self._is_prefixed
+
+class PhysicalConstant(Quantity):
+    """Represents a physical constant, eg. `speed_of_light` or `avogadro_constant`."""
+
+    is_physical_constant = True

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/systems/__init__.py

@@ -0,0 +1,6 @@
+from sympy.physics.units.systems.mks import MKS
+from sympy.physics.units.systems.mksa import MKSA
+from sympy.physics.units.systems.natural import natural
+from sympy.physics.units.systems.si import SI
+
+__all__ = ['MKS', 'MKSA', 'natural', 'SI']

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/systems/cgs.py

@@ -0,0 +1,82 @@
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.units import UnitSystem, centimeter, gram, second, coulomb, charge, speed_of_light, current, mass, \
+    length, voltage, magnetic_density, magnetic_flux
+from sympy.physics.units.definitions import coulombs_constant
+from sympy.physics.units.definitions.unit_definitions import statcoulomb, statampere, statvolt, volt, tesla, gauss, \
+    weber, maxwell, debye, oersted, ohm, farad, henry, erg, ampere, coulomb_constant
+from sympy.physics.units.systems.mks import dimsys_length_weight_time
+
+One = S.One
+
+dimsys_cgs = dimsys_length_weight_time.extend(
+    [],
+    new_dim_deps={
+        # Dimensional dependencies for derived dimensions
+        "impedance": {"time": 1, "length": -1},
+        "conductance": {"time": -1, "length": 1},
+        "capacitance": {"length": 1},
+        "inductance": {"time": 2, "length": -1},
+        "charge": {"mass": S.Half, "length": S(3)/2, "time": -1},
+        "current": {"mass": One/2, "length": 3*One/2, "time": -2},
+        "voltage": {"length": -One/2, "mass": One/2, "time": -1},
+        "magnetic_density": {"length": -One/2, "mass": One/2, "time": -1},
+        "magnetic_flux": {"length": 3*One/2, "mass": One/2, "time": -1},
+    }
+)
+
+cgs_gauss = UnitSystem(
+    base_units=[centimeter, gram, second],
+    units=[],
+    name="cgs_gauss",
+    dimension_system=dimsys_cgs)
+
+
+cgs_gauss.set_quantity_scale_factor(coulombs_constant, 1)
+
+cgs_gauss.set_quantity_dimension(statcoulomb, charge)
+cgs_gauss.set_quantity_scale_factor(statcoulomb, centimeter**(S(3)/2)*gram**(S.Half)/second)
+
+cgs_gauss.set_quantity_dimension(coulomb, charge)
+
+cgs_gauss.set_quantity_dimension(statampere, current)
+cgs_gauss.set_quantity_scale_factor(statampere, statcoulomb/second)
+
+cgs_gauss.set_quantity_dimension(statvolt, voltage)
+cgs_gauss.set_quantity_scale_factor(statvolt, erg/statcoulomb)
+
+cgs_gauss.set_quantity_dimension(volt, voltage)
+
+cgs_gauss.set_quantity_dimension(gauss, magnetic_density)
+cgs_gauss.set_quantity_scale_factor(gauss, sqrt(gram/centimeter)/second)
+
+cgs_gauss.set_quantity_dimension(tesla, magnetic_density)
+
+cgs_gauss.set_quantity_dimension(maxwell, magnetic_flux)
+cgs_gauss.set_quantity_scale_factor(maxwell, sqrt(centimeter**3*gram)/second)
+
+# SI units expressed in CGS-gaussian units:
+cgs_gauss.set_quantity_scale_factor(coulomb, 10*speed_of_light*statcoulomb)
+cgs_gauss.set_quantity_scale_factor(ampere, 10*speed_of_light*statcoulomb/second)
+cgs_gauss.set_quantity_scale_factor(volt, 10**6/speed_of_light*statvolt)
+cgs_gauss.set_quantity_scale_factor(weber, 10**8*maxwell)
+cgs_gauss.set_quantity_scale_factor(tesla, 10**4*gauss)
+cgs_gauss.set_quantity_scale_factor(debye, One/10**18*statcoulomb*centimeter)
+cgs_gauss.set_quantity_scale_factor(oersted, sqrt(gram/centimeter)/second)
+cgs_gauss.set_quantity_scale_factor(ohm, 10**5/speed_of_light**2*second/centimeter)
+cgs_gauss.set_quantity_scale_factor(farad, One/10**5*speed_of_light**2*centimeter)
+cgs_gauss.set_quantity_scale_factor(henry, 10**5/speed_of_light**2/centimeter*second**2)
+
+# Coulomb's constant:
+cgs_gauss.set_quantity_dimension(coulomb_constant, 1)
+cgs_gauss.set_quantity_scale_factor(coulomb_constant, 1)
+
+__all__ = [
+    'ohm', 'tesla', 'maxwell', 'speed_of_light', 'volt', 'second', 'voltage',
+    'debye', 'dimsys_length_weight_time', 'centimeter', 'coulomb_constant',
+    'farad', 'sqrt', 'UnitSystem', 'current', 'charge', 'weber', 'gram',
+    'statcoulomb', 'gauss', 'S', 'statvolt', 'oersted', 'statampere',
+    'dimsys_cgs', 'coulomb', 'magnetic_density', 'magnetic_flux', 'One',
+    'length', 'erg', 'mass', 'coulombs_constant', 'henry', 'ampere',
+    'cgs_gauss',
+]

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/systems/length_weight_time.py

@@ -0,0 +1,156 @@
+from sympy.core.singleton import S
+
+from sympy.core.numbers import pi
+
+from sympy.physics.units import DimensionSystem, hertz, kilogram
+from sympy.physics.units.definitions import (
+    G, Hz, J, N, Pa, W, c, g, kg, m, s, meter, gram, second, newton,
+    joule, watt, pascal)
+from sympy.physics.units.definitions.dimension_definitions import (
+    acceleration, action, energy, force, frequency, momentum,
+    power, pressure, velocity, length, mass, time)
+from sympy.physics.units.prefixes import PREFIXES, prefix_unit
+from sympy.physics.units.prefixes import (
+    kibi, mebi, gibi, tebi, pebi, exbi
+)
+from sympy.physics.units.definitions import (
+    cd, K, coulomb, volt, ohm, siemens, farad, henry, tesla, weber, dioptre,
+    lux, katal, gray, becquerel, inch, hectare, liter, julian_year,
+    gravitational_constant, speed_of_light, elementary_charge, planck, hbar,
+    electronvolt, avogadro_number, avogadro_constant, boltzmann_constant,
+    stefan_boltzmann_constant, atomic_mass_constant, molar_gas_constant,
+    faraday_constant, josephson_constant, von_klitzing_constant,
+    acceleration_due_to_gravity, magnetic_constant, vacuum_permittivity,
+    vacuum_impedance, coulomb_constant, atmosphere, bar, pound, psi, mmHg,
+    milli_mass_unit, quart, lightyear, astronomical_unit, planck_mass,
+    planck_time, planck_temperature, planck_length, planck_charge,
+    planck_area, planck_volume, planck_momentum, planck_energy, planck_force,
+    planck_power, planck_density, planck_energy_density, planck_intensity,
+    planck_angular_frequency, planck_pressure, planck_current, planck_voltage,
+    planck_impedance, planck_acceleration, bit, byte, kibibyte, mebibyte,
+    gibibyte, tebibyte, pebibyte, exbibyte, curie, rutherford, radian, degree,
+    steradian, angular_mil, atomic_mass_unit, gee, kPa, ampere, u0, kelvin,
+    mol, mole, candela, electric_constant, boltzmann, angstrom
+)
+
+
+dimsys_length_weight_time = DimensionSystem([
+    # Dimensional dependencies for MKS base dimensions
+    length,
+    mass,
+    time,
+], dimensional_dependencies={
+    # Dimensional dependencies for derived dimensions
+    "velocity": {"length": 1, "time": -1},
+    "acceleration": {"length": 1, "time": -2},
+    "momentum": {"mass": 1, "length": 1, "time": -1},
+    "force": {"mass": 1, "length": 1, "time": -2},
+    "energy": {"mass": 1, "length": 2, "time": -2},
+    "power": {"length": 2, "mass": 1, "time": -3},
+    "pressure": {"mass": 1, "length": -1, "time": -2},
+    "frequency": {"time": -1},
+    "action": {"length": 2, "mass": 1, "time": -1},
+    "area": {"length": 2},
+    "volume": {"length": 3},
+})
+
+
+One = S.One
+
+
+# Base units:
+dimsys_length_weight_time.set_quantity_dimension(meter, length)
+dimsys_length_weight_time.set_quantity_scale_factor(meter, One)
+
+# gram; used to define its prefixed units
+dimsys_length_weight_time.set_quantity_dimension(gram, mass)
+dimsys_length_weight_time.set_quantity_scale_factor(gram, One)
+
+dimsys_length_weight_time.set_quantity_dimension(second, time)
+dimsys_length_weight_time.set_quantity_scale_factor(second, One)
+
+# derived units
+
+dimsys_length_weight_time.set_quantity_dimension(newton, force)
+dimsys_length_weight_time.set_quantity_scale_factor(newton, kilogram*meter/second**2)
+
+dimsys_length_weight_time.set_quantity_dimension(joule, energy)
+dimsys_length_weight_time.set_quantity_scale_factor(joule, newton*meter)
+
+dimsys_length_weight_time.set_quantity_dimension(watt, power)
+dimsys_length_weight_time.set_quantity_scale_factor(watt, joule/second)
+
+dimsys_length_weight_time.set_quantity_dimension(pascal, pressure)
+dimsys_length_weight_time.set_quantity_scale_factor(pascal, newton/meter**2)
+
+dimsys_length_weight_time.set_quantity_dimension(hertz, frequency)
+dimsys_length_weight_time.set_quantity_scale_factor(hertz, One)
+
+# Other derived units:
+
+dimsys_length_weight_time.set_quantity_dimension(dioptre, 1 / length)
+dimsys_length_weight_time.set_quantity_scale_factor(dioptre, 1/meter)
+
+# Common volume and area units
+
+dimsys_length_weight_time.set_quantity_dimension(hectare, length**2)
+dimsys_length_weight_time.set_quantity_scale_factor(hectare, (meter**2)*(10000))
+
+dimsys_length_weight_time.set_quantity_dimension(liter, length**3)
+dimsys_length_weight_time.set_quantity_scale_factor(liter, meter**3/1000)
+
+
+# Newton constant
+# REF: NIST SP 959 (June 2019)
+
+dimsys_length_weight_time.set_quantity_dimension(gravitational_constant, length ** 3 * mass ** -1 * time ** -2)
+dimsys_length_weight_time.set_quantity_scale_factor(gravitational_constant, 6.67430e-11*m**3/(kg*s**2))
+
+# speed of light
+
+dimsys_length_weight_time.set_quantity_dimension(speed_of_light, velocity)
+dimsys_length_weight_time.set_quantity_scale_factor(speed_of_light, 299792458*meter/second)
+
+
+# Planck constant
+# REF: NIST SP 959 (June 2019)
+
+dimsys_length_weight_time.set_quantity_dimension(planck, action)
+dimsys_length_weight_time.set_quantity_scale_factor(planck, 6.62607015e-34*joule*second)
+
+# Reduced Planck constant
+# REF: NIST SP 959 (June 2019)
+
+dimsys_length_weight_time.set_quantity_dimension(hbar, action)
+dimsys_length_weight_time.set_quantity_scale_factor(hbar, planck / (2 * pi))
+
+
+__all__ = [
+    'mmHg', 'atmosphere', 'newton', 'meter', 'vacuum_permittivity', 'pascal',
+    'magnetic_constant', 'angular_mil', 'julian_year', 'weber', 'exbibyte',
+    'liter', 'molar_gas_constant', 'faraday_constant', 'avogadro_constant',
+    'planck_momentum', 'planck_density', 'gee', 'mol', 'bit', 'gray', 'kibi',
+    'bar', 'curie', 'prefix_unit', 'PREFIXES', 'planck_time', 'gram',
+    'candela', 'force', 'planck_intensity', 'energy', 'becquerel',
+    'planck_acceleration', 'speed_of_light', 'dioptre', 'second', 'frequency',
+    'Hz', 'power', 'lux', 'planck_current', 'momentum', 'tebibyte',
+    'planck_power', 'degree', 'mebi', 'K', 'planck_volume',
+    'quart', 'pressure', 'W', 'joule', 'boltzmann_constant', 'c', 'g',
+    'planck_force', 'exbi', 's', 'watt', 'action', 'hbar', 'gibibyte',
+    'DimensionSystem', 'cd', 'volt', 'planck_charge', 'angstrom',
+    'dimsys_length_weight_time', 'pebi', 'vacuum_impedance', 'planck',
+    'farad', 'gravitational_constant', 'u0', 'hertz', 'tesla', 'steradian',
+    'josephson_constant', 'planck_area', 'stefan_boltzmann_constant',
+    'astronomical_unit', 'J', 'N', 'planck_voltage', 'planck_energy',
+    'atomic_mass_constant', 'rutherford', 'elementary_charge', 'Pa',
+    'planck_mass', 'henry', 'planck_angular_frequency', 'ohm', 'pound',
+    'planck_pressure', 'G', 'avogadro_number', 'psi', 'von_klitzing_constant',
+    'planck_length', 'radian', 'mole', 'acceleration',
+    'planck_energy_density', 'mebibyte', 'length',
+    'acceleration_due_to_gravity', 'planck_temperature', 'tebi', 'inch',
+    'electronvolt', 'coulomb_constant', 'kelvin', 'kPa', 'boltzmann',
+    'milli_mass_unit', 'gibi', 'planck_impedance', 'electric_constant', 'kg',
+    'coulomb', 'siemens', 'byte', 'atomic_mass_unit', 'm', 'kibibyte',
+    'kilogram', 'lightyear', 'mass', 'time', 'pebibyte', 'velocity',
+    'ampere', 'katal',
+]

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/systems/mks.py

@@ -0,0 +1,46 @@
+"""
+MKS unit system.
+
+MKS stands for "meter, kilogram, second".
+"""
+
+from sympy.physics.units import UnitSystem
+from sympy.physics.units.definitions import gravitational_constant, hertz, joule, newton, pascal, watt, speed_of_light, gram, kilogram, meter, second
+from sympy.physics.units.definitions.dimension_definitions import (
+    acceleration, action, energy, force, frequency, momentum,
+    power, pressure, velocity, length, mass, time)
+from sympy.physics.units.prefixes import PREFIXES, prefix_unit
+from sympy.physics.units.systems.length_weight_time import dimsys_length_weight_time
+
+dims = (velocity, acceleration, momentum, force, energy, power, pressure,
+        frequency, action)
+
+units = [meter, gram, second, joule, newton, watt, pascal, hertz]
+all_units = []
+
+# Prefixes of units like gram, joule, newton etc get added using `prefix_unit`
+# in the for loop, but the actual units have to be added manually.
+all_units.extend([gram, joule, newton, watt, pascal, hertz])
+
+for u in units:
+    all_units.extend(prefix_unit(u, PREFIXES))
+all_units.extend([gravitational_constant, speed_of_light])
+
+# unit system
+MKS = UnitSystem(base_units=(meter, kilogram, second), units=all_units, name="MKS", dimension_system=dimsys_length_weight_time, derived_units={
+    power: watt,
+    time: second,
+    pressure: pascal,
+    length: meter,
+    frequency: hertz,
+    mass: kilogram,
+    force: newton,
+    energy: joule,
+    velocity: meter/second,
+    acceleration: meter/(second**2),
+})
+
+
+__all__ = [
+    'MKS', 'units', 'all_units', 'dims',
+]

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/systems/mksa.py

@@ -0,0 +1,54 @@
+"""
+MKS unit system.
+
+MKS stands for "meter, kilogram, second, ampere".
+"""
+
+from __future__ import annotations
+
+from sympy.physics.units.definitions import Z0, ampere, coulomb, farad, henry, siemens, tesla, volt, weber, ohm
+from sympy.physics.units.definitions.dimension_definitions import (
+    capacitance, charge, conductance, current, impedance, inductance,
+    magnetic_density, magnetic_flux, voltage)
+from sympy.physics.units.prefixes import PREFIXES, prefix_unit
+from sympy.physics.units.systems.mks import MKS, dimsys_length_weight_time
+from sympy.physics.units.quantities import Quantity
+
+dims = (voltage, impedance, conductance, current, capacitance, inductance, charge,
+        magnetic_density, magnetic_flux)
+
+units = [ampere, volt, ohm, siemens, farad, henry, coulomb, tesla, weber]
+
+all_units: list[Quantity] = []
+for u in units:
+    all_units.extend(prefix_unit(u, PREFIXES))
+all_units.extend(units)
+
+all_units.append(Z0)
+
+dimsys_MKSA = dimsys_length_weight_time.extend([
+    # Dimensional dependencies for base dimensions (MKSA not in MKS)
+    current,
+], new_dim_deps={
+    # Dimensional dependencies for derived dimensions
+    "voltage": {"mass": 1, "length": 2, "current": -1, "time": -3},
+    "impedance": {"mass": 1, "length": 2, "current": -2, "time": -3},
+    "conductance": {"mass": -1, "length": -2, "current": 2, "time": 3},
+    "capacitance": {"mass": -1, "length": -2, "current": 2, "time": 4},
+    "inductance": {"mass": 1, "length": 2, "current": -2, "time": -2},
+    "charge": {"current": 1, "time": 1},
+    "magnetic_density": {"mass": 1, "current": -1, "time": -2},
+    "magnetic_flux": {"length": 2, "mass": 1, "current": -1, "time": -2},
+})
+
+MKSA = MKS.extend(base=(ampere,), units=all_units, name='MKSA', dimension_system=dimsys_MKSA, derived_units={
+    magnetic_flux: weber,
+    impedance: ohm,
+    current: ampere,
+    voltage: volt,
+    inductance: henry,
+    conductance: siemens,
+    magnetic_density: tesla,
+    charge: coulomb,
+    capacitance: farad,
+})

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/systems/natural.py

@@ -0,0 +1,27 @@
+"""
+Naturalunit system.
+
+The natural system comes from "setting c = 1, hbar = 1". From the computer
+point of view it means that we use velocity and action instead of length and
+time. Moreover instead of mass we use energy.
+"""
+
+from sympy.physics.units import DimensionSystem
+from sympy.physics.units.definitions import c, eV, hbar
+from sympy.physics.units.definitions.dimension_definitions import (
+    action, energy, force, frequency, length, mass, momentum,
+    power, time, velocity)
+from sympy.physics.units.prefixes import PREFIXES, prefix_unit
+from sympy.physics.units.unitsystem import UnitSystem
+
+
+# dimension system
+_natural_dim = DimensionSystem(
+    base_dims=(action, energy, velocity),
+    derived_dims=(length, mass, time, momentum, force, power, frequency)
+)
+
+units = prefix_unit(eV, PREFIXES)
+
+# unit system
+natural = UnitSystem(base_units=(hbar, eV, c), units=units, name="Natural system")

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/systems/si.py

@@ -0,0 +1,377 @@
+"""
+SI unit system.
+Based on MKSA, which stands for "meter, kilogram, second, ampere".
+Added kelvin, candela and mole.
+
+"""
+
+from __future__ import annotations
+
+from sympy.physics.units import DimensionSystem, Dimension, dHg0
+
+from sympy.physics.units.quantities import Quantity
+
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.units.definitions.dimension_definitions import (
+    acceleration, action, current, impedance, length, mass, time, velocity,
+    amount_of_substance, temperature, information, frequency, force, pressure,
+    energy, power, charge, voltage, capacitance, conductance, magnetic_flux,
+    magnetic_density, inductance, luminous_intensity
+)
+from sympy.physics.units.definitions import (
+    kilogram, newton, second, meter, gram, cd, K, joule, watt, pascal, hertz,
+    coulomb, volt, ohm, siemens, farad, henry, tesla, weber, dioptre, lux,
+    katal, gray, becquerel, inch, liter, julian_year, gravitational_constant,
+    speed_of_light, elementary_charge, planck, hbar, electronvolt,
+    avogadro_number, avogadro_constant, boltzmann_constant, electron_rest_mass,
+    stefan_boltzmann_constant, Da, atomic_mass_constant, molar_gas_constant,
+    faraday_constant, josephson_constant, von_klitzing_constant,
+    acceleration_due_to_gravity, magnetic_constant, vacuum_permittivity,
+    vacuum_impedance, coulomb_constant, atmosphere, bar, pound, psi, mmHg,
+    milli_mass_unit, quart, lightyear, astronomical_unit, planck_mass,
+    planck_time, planck_temperature, planck_length, planck_charge, planck_area,
+    planck_volume, planck_momentum, planck_energy, planck_force, planck_power,
+    planck_density, planck_energy_density, planck_intensity,
+    planck_angular_frequency, planck_pressure, planck_current, planck_voltage,
+    planck_impedance, planck_acceleration, bit, byte, kibibyte, mebibyte,
+    gibibyte, tebibyte, pebibyte, exbibyte, curie, rutherford, radian, degree,
+    steradian, angular_mil, atomic_mass_unit, gee, kPa, ampere, u0, c, kelvin,
+    mol, mole, candela, m, kg, s, electric_constant, G, boltzmann
+)
+from sympy.physics.units.prefixes import PREFIXES, prefix_unit
+from sympy.physics.units.systems.mksa import MKSA, dimsys_MKSA
+
+derived_dims = (frequency, force, pressure, energy, power, charge, voltage,
+                capacitance, conductance, magnetic_flux,
+                magnetic_density, inductance, luminous_intensity)
+base_dims = (amount_of_substance, luminous_intensity, temperature)
+
+units = [mol, cd, K, lux, hertz, newton, pascal, joule, watt, coulomb, volt,
+        farad, ohm, siemens, weber, tesla, henry, candela, lux, becquerel,
+        gray, katal]
+
+all_units: list[Quantity] = []
+for u in units:
+    all_units.extend(prefix_unit(u, PREFIXES))
+
+all_units.extend(units)
+all_units.extend([mol, cd, K, lux])
+
+
+dimsys_SI = dimsys_MKSA.extend(
+    [
+        # Dimensional dependencies for other base dimensions:
+        temperature,
+        amount_of_substance,
+        luminous_intensity,
+    ])
+
+dimsys_default = dimsys_SI.extend(
+    [information],
+)
+
+SI = MKSA.extend(base=(mol, cd, K), units=all_units, name='SI', dimension_system=dimsys_SI, derived_units={
+    power: watt,
+    magnetic_flux: weber,
+    time: second,
+    impedance: ohm,
+    pressure: pascal,
+    current: ampere,
+    voltage: volt,
+    length: meter,
+    frequency: hertz,
+    inductance: henry,
+    temperature: kelvin,
+    amount_of_substance: mole,
+    luminous_intensity: candela,
+    conductance: siemens,
+    mass: kilogram,
+    magnetic_density: tesla,
+    charge: coulomb,
+    force: newton,
+    capacitance: farad,
+    energy: joule,
+    velocity: meter/second,
+})
+
+One = S.One
+
+SI.set_quantity_dimension(radian, One)
+
+SI.set_quantity_scale_factor(ampere, One)
+
+SI.set_quantity_scale_factor(kelvin, One)
+
+SI.set_quantity_scale_factor(mole, One)
+
+SI.set_quantity_scale_factor(candela, One)
+
+# MKSA extension to MKS: derived units
+
+SI.set_quantity_scale_factor(coulomb, One)
+
+SI.set_quantity_scale_factor(volt, joule/coulomb)
+
+SI.set_quantity_scale_factor(ohm, volt/ampere)
+
+SI.set_quantity_scale_factor(siemens, ampere/volt)
+
+SI.set_quantity_scale_factor(farad, coulomb/volt)
+
+SI.set_quantity_scale_factor(henry, volt*second/ampere)
+
+SI.set_quantity_scale_factor(tesla, volt*second/meter**2)
+
+SI.set_quantity_scale_factor(weber, joule/ampere)
+
+
+SI.set_quantity_dimension(lux, luminous_intensity / length ** 2)
+SI.set_quantity_scale_factor(lux, steradian*candela/meter**2)
+
+# katal is the SI unit of catalytic activity
+
+SI.set_quantity_dimension(katal, amount_of_substance / time)
+SI.set_quantity_scale_factor(katal, mol/second)
+
+# gray is the SI unit of absorbed dose
+
+SI.set_quantity_dimension(gray, energy / mass)
+SI.set_quantity_scale_factor(gray, meter**2/second**2)
+
+# becquerel is the SI unit of radioactivity
+
+SI.set_quantity_dimension(becquerel, 1 / time)
+SI.set_quantity_scale_factor(becquerel, 1/second)
+
+#### CONSTANTS ####
+
+# elementary charge
+# REF: NIST SP 959 (June 2019)
+
+SI.set_quantity_dimension(elementary_charge, charge)
+SI.set_quantity_scale_factor(elementary_charge, 1.602176634e-19*coulomb)
+
+# Electronvolt
+# REF: NIST SP 959 (June 2019)
+
+SI.set_quantity_dimension(electronvolt, energy)
+SI.set_quantity_scale_factor(electronvolt, 1.602176634e-19*joule)
+
+# Avogadro number
+# REF: NIST SP 959 (June 2019)
+
+SI.set_quantity_dimension(avogadro_number, One)
+SI.set_quantity_scale_factor(avogadro_number, 6.02214076e23)
+
+# Avogadro constant
+
+SI.set_quantity_dimension(avogadro_constant, amount_of_substance ** -1)
+SI.set_quantity_scale_factor(avogadro_constant, avogadro_number / mol)
+
+# Boltzmann constant
+# REF: NIST SP 959 (June 2019)
+
+SI.set_quantity_dimension(boltzmann_constant, energy / temperature)
+SI.set_quantity_scale_factor(boltzmann_constant, 1.380649e-23*joule/kelvin)
+
+# Stefan-Boltzmann constant
+# REF: NIST SP 959 (June 2019)
+
+SI.set_quantity_dimension(stefan_boltzmann_constant, energy * time ** -1 * length ** -2 * temperature ** -4)
+SI.set_quantity_scale_factor(stefan_boltzmann_constant, pi**2 * boltzmann_constant**4 / (60 * hbar**3 * speed_of_light ** 2))
+
+# Atomic mass
+# REF: NIST SP 959 (June 2019)
+
+SI.set_quantity_dimension(atomic_mass_constant, mass)
+SI.set_quantity_scale_factor(atomic_mass_constant, 1.66053906660e-24*gram)
+
+# Molar gas constant
+# REF: NIST SP 959 (June 2019)
+
+SI.set_quantity_dimension(molar_gas_constant, energy / (temperature * amount_of_substance))
+SI.set_quantity_scale_factor(molar_gas_constant, boltzmann_constant * avogadro_constant)
+
+# Faraday constant
+
+SI.set_quantity_dimension(faraday_constant, charge / amount_of_substance)
+SI.set_quantity_scale_factor(faraday_constant, elementary_charge * avogadro_constant)
+
+# Josephson constant
+
+SI.set_quantity_dimension(josephson_constant, frequency / voltage)
+SI.set_quantity_scale_factor(josephson_constant, 0.5 * planck / elementary_charge)
+
+# Von Klitzing constant
+
+SI.set_quantity_dimension(von_klitzing_constant, voltage / current)
+SI.set_quantity_scale_factor(von_klitzing_constant, hbar / elementary_charge ** 2)
+
+# Acceleration due to gravity (on the Earth surface)
+
+SI.set_quantity_dimension(acceleration_due_to_gravity, acceleration)
+SI.set_quantity_scale_factor(acceleration_due_to_gravity, 9.80665*meter/second**2)
+
+# magnetic constant:
+
+SI.set_quantity_dimension(magnetic_constant, force / current ** 2)
+SI.set_quantity_scale_factor(magnetic_constant, 4*pi/10**7 * newton/ampere**2)
+
+# electric constant:
+
+SI.set_quantity_dimension(vacuum_permittivity, capacitance / length)
+SI.set_quantity_scale_factor(vacuum_permittivity, 1/(u0 * c**2))
+
+# vacuum impedance:
+
+SI.set_quantity_dimension(vacuum_impedance, impedance)
+SI.set_quantity_scale_factor(vacuum_impedance, u0 * c)
+
+# Electron rest mass
+SI.set_quantity_dimension(electron_rest_mass, mass)
+SI.set_quantity_scale_factor(electron_rest_mass, 9.1093837015e-31*kilogram)
+
+# Coulomb's constant:
+SI.set_quantity_dimension(coulomb_constant, force * length ** 2 / charge ** 2)
+SI.set_quantity_scale_factor(coulomb_constant, 1/(4*pi*vacuum_permittivity))
+
+SI.set_quantity_dimension(psi, pressure)
+SI.set_quantity_scale_factor(psi, pound * gee / inch ** 2)
+
+SI.set_quantity_dimension(mmHg, pressure)
+SI.set_quantity_scale_factor(mmHg, dHg0 * acceleration_due_to_gravity * kilogram / meter**2)
+
+SI.set_quantity_dimension(milli_mass_unit, mass)
+SI.set_quantity_scale_factor(milli_mass_unit, atomic_mass_unit/1000)
+
+SI.set_quantity_dimension(quart, length ** 3)
+SI.set_quantity_scale_factor(quart, Rational(231, 4) * inch**3)
+
+# Other convenient units and magnitudes
+
+SI.set_quantity_dimension(lightyear, length)
+SI.set_quantity_scale_factor(lightyear, speed_of_light*julian_year)
+
+SI.set_quantity_dimension(astronomical_unit, length)
+SI.set_quantity_scale_factor(astronomical_unit, 149597870691*meter)
+
+# Fundamental Planck units:
+
+SI.set_quantity_dimension(planck_mass, mass)
+SI.set_quantity_scale_factor(planck_mass, sqrt(hbar*speed_of_light/G))
+
+SI.set_quantity_dimension(planck_time, time)
+SI.set_quantity_scale_factor(planck_time, sqrt(hbar*G/speed_of_light**5))
+
+SI.set_quantity_dimension(planck_temperature, temperature)
+SI.set_quantity_scale_factor(planck_temperature, sqrt(hbar*speed_of_light**5/G/boltzmann**2))
+
+SI.set_quantity_dimension(planck_length, length)
+SI.set_quantity_scale_factor(planck_length, sqrt(hbar*G/speed_of_light**3))
+
+SI.set_quantity_dimension(planck_charge, charge)
+SI.set_quantity_scale_factor(planck_charge, sqrt(4*pi*electric_constant*hbar*speed_of_light))
+
+# Derived Planck units:
+
+SI.set_quantity_dimension(planck_area, length ** 2)
+SI.set_quantity_scale_factor(planck_area, planck_length**2)
+
+SI.set_quantity_dimension(planck_volume, length ** 3)
+SI.set_quantity_scale_factor(planck_volume, planck_length**3)
+
+SI.set_quantity_dimension(planck_momentum, mass * velocity)
+SI.set_quantity_scale_factor(planck_momentum, planck_mass * speed_of_light)
+
+SI.set_quantity_dimension(planck_energy, energy)
+SI.set_quantity_scale_factor(planck_energy, planck_mass * speed_of_light**2)
+
+SI.set_quantity_dimension(planck_force, force)
+SI.set_quantity_scale_factor(planck_force, planck_energy / planck_length)
+
+SI.set_quantity_dimension(planck_power, power)
+SI.set_quantity_scale_factor(planck_power, planck_energy / planck_time)
+
+SI.set_quantity_dimension(planck_density, mass / length ** 3)
+SI.set_quantity_scale_factor(planck_density, planck_mass / planck_length**3)
+
+SI.set_quantity_dimension(planck_energy_density, energy / length ** 3)
+SI.set_quantity_scale_factor(planck_energy_density, planck_energy / planck_length**3)
+
+SI.set_quantity_dimension(planck_intensity, mass * time ** (-3))
+SI.set_quantity_scale_factor(planck_intensity, planck_energy_density * speed_of_light)
+
+SI.set_quantity_dimension(planck_angular_frequency, 1 / time)
+SI.set_quantity_scale_factor(planck_angular_frequency, 1 / planck_time)
+
+SI.set_quantity_dimension(planck_pressure, pressure)
+SI.set_quantity_scale_factor(planck_pressure, planck_force / planck_length**2)
+
+SI.set_quantity_dimension(planck_current, current)
+SI.set_quantity_scale_factor(planck_current, planck_charge / planck_time)
+
+SI.set_quantity_dimension(planck_voltage, voltage)
+SI.set_quantity_scale_factor(planck_voltage, planck_energy / planck_charge)
+
+SI.set_quantity_dimension(planck_impedance, impedance)
+SI.set_quantity_scale_factor(planck_impedance, planck_voltage / planck_current)
+
+SI.set_quantity_dimension(planck_acceleration, acceleration)
+SI.set_quantity_scale_factor(planck_acceleration, speed_of_light / planck_time)
+
+# Older units for radioactivity
+
+SI.set_quantity_dimension(curie, 1 / time)
+SI.set_quantity_scale_factor(curie, 37000000000*becquerel)
+
+SI.set_quantity_dimension(rutherford, 1 / time)
+SI.set_quantity_scale_factor(rutherford, 1000000*becquerel)
+
+
+# check that scale factors are the right SI dimensions:
+for _scale_factor, _dimension in zip(
+    SI._quantity_scale_factors.values(),
+    SI._quantity_dimension_map.values()
+):
+    dimex = SI.get_dimensional_expr(_scale_factor)
+    if dimex != 1:
+        # XXX: equivalent_dims is an instance method taking two arguments in
+        # addition to self so this can not work:
+        if not DimensionSystem.equivalent_dims(_dimension, Dimension(dimex)):  # type: ignore
+            raise ValueError("quantity value and dimension mismatch")
+del _scale_factor, _dimension
+
+__all__ = [
+    'mmHg', 'atmosphere', 'inductance', 'newton', 'meter',
+    'vacuum_permittivity', 'pascal', 'magnetic_constant', 'voltage',
+    'angular_mil', 'luminous_intensity', 'all_units',
+    'julian_year', 'weber', 'exbibyte', 'liter',
+    'molar_gas_constant', 'faraday_constant', 'avogadro_constant',
+    'lightyear', 'planck_density', 'gee', 'mol', 'bit', 'gray',
+    'planck_momentum', 'bar', 'magnetic_density', 'prefix_unit', 'PREFIXES',
+    'planck_time', 'dimex', 'gram', 'candela', 'force', 'planck_intensity',
+    'energy', 'becquerel', 'planck_acceleration', 'speed_of_light',
+    'conductance', 'frequency', 'coulomb_constant', 'degree', 'lux', 'planck',
+    'current', 'planck_current', 'tebibyte', 'planck_power', 'MKSA', 'power',
+    'K', 'planck_volume', 'quart', 'pressure', 'amount_of_substance',
+    'joule', 'boltzmann_constant', 'Dimension', 'c', 'planck_force', 'length',
+    'watt', 'action', 'hbar', 'gibibyte', 'DimensionSystem', 'cd', 'volt',
+    'planck_charge', 'dioptre', 'vacuum_impedance', 'dimsys_default', 'farad',
+    'charge', 'gravitational_constant', 'temperature', 'u0', 'hertz',
+    'capacitance', 'tesla', 'steradian', 'planck_mass', 'josephson_constant',
+    'planck_area', 'stefan_boltzmann_constant', 'base_dims',
+    'astronomical_unit', 'radian', 'planck_voltage', 'impedance',
+    'planck_energy', 'Da', 'atomic_mass_constant', 'rutherford', 'second', 'inch',
+    'elementary_charge', 'SI', 'electronvolt', 'dimsys_SI', 'henry',
+    'planck_angular_frequency', 'ohm', 'pound', 'planck_pressure', 'G', 'psi',
+    'dHg0', 'von_klitzing_constant', 'planck_length', 'avogadro_number',
+    'mole', 'acceleration', 'information', 'planck_energy_density',
+    'mebibyte', 's', 'acceleration_due_to_gravity', 'electron_rest_mass',
+    'planck_temperature', 'units', 'mass', 'dimsys_MKSA', 'kelvin', 'kPa',
+    'boltzmann', 'milli_mass_unit', 'planck_impedance', 'electric_constant',
+    'derived_dims', 'kg', 'coulomb', 'siemens', 'byte', 'magnetic_flux',
+    'atomic_mass_unit', 'm', 'kibibyte', 'kilogram', 'One', 'curie', 'u',
+    'time', 'pebibyte', 'velocity', 'ampere', 'katal',
+]

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/tests/test_dimensions.py

@@ -0,0 +1,150 @@
+from sympy.physics.units.systems.si import dimsys_SI
+
+from sympy.core.numbers import pi
+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 log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, atan2, cos)
+from sympy.physics.units.dimensions import Dimension
+from sympy.physics.units.definitions.dimension_definitions import (
+    length, time, mass, force, pressure, angle
+)
+from sympy.physics.units import foot
+from sympy.testing.pytest import raises
+
+
+def test_Dimension_definition():
+    assert dimsys_SI.get_dimensional_dependencies(length) == {length: 1}
+    assert length.name == Symbol("length")
+    assert length.symbol == Symbol("L")
+
+    halflength = sqrt(length)
+    assert dimsys_SI.get_dimensional_dependencies(halflength) == {length: S.Half}
+
+
+def test_Dimension_error_definition():
+    # tuple with more or less than two entries
+    raises(TypeError, lambda: Dimension(("length", 1, 2)))
+    raises(TypeError, lambda: Dimension(["length"]))
+
+    # non-number power
+    raises(TypeError, lambda: Dimension({"length": "a"}))
+
+    # non-number with named argument
+    raises(TypeError, lambda: Dimension({"length": (1, 2)}))
+
+    # symbol should by Symbol or str
+    raises(AssertionError, lambda: Dimension("length", symbol=1))
+
+
+def test_str():
+    assert str(Dimension("length")) == "Dimension(length)"
+    assert str(Dimension("length", "L")) == "Dimension(length, L)"
+
+
+def test_Dimension_properties():
+    assert dimsys_SI.is_dimensionless(length) is False
+    assert dimsys_SI.is_dimensionless(length/length) is True
+    assert dimsys_SI.is_dimensionless(Dimension("undefined")) is False
+
+    assert length.has_integer_powers(dimsys_SI) is True
+    assert (length**(-1)).has_integer_powers(dimsys_SI) is True
+    assert (length**1.5).has_integer_powers(dimsys_SI) is False
+
+
+def test_Dimension_add_sub():
+    assert length + length == length
+    assert length - length == length
+    assert -length == length
+
+    raises(TypeError, lambda: length + foot)
+    raises(TypeError, lambda: foot + length)
+    raises(TypeError, lambda: length - foot)
+    raises(TypeError, lambda: foot - length)
+
+    # issue 14547 - only raise error for dimensional args; allow
+    # others to pass
+    x = Symbol('x')
+    e = length + x
+    assert e == x + length and e.is_Add and set(e.args) == {length, x}
+    e = length + 1
+    assert e == 1 + length == 1 - length and e.is_Add and set(e.args) == {length, 1}
+
+    assert dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + force) == \
+            {length: 1, mass: 1, time: -2}
+    assert dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + force -
+                                                   pressure * length**2) == \
+            {length: 1, mass: 1, time: -2}
+
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + pressure))
+
+def test_Dimension_mul_div_exp():
+    assert 2*length == length*2 == length/2 == length
+    assert 2/length == 1/length
+    x = Symbol('x')
+    m = x*length
+    assert m == length*x and m.is_Mul and set(m.args) == {x, length}
+    d = x/length
+    assert d == x*length**-1 and d.is_Mul and set(d.args) == {x, 1/length}
+    d = length/x
+    assert d == length*x**-1 and d.is_Mul and set(d.args) == {1/x, length}
+
+    velo = length / time
+
+    assert (length * length) == length ** 2
+
+    assert dimsys_SI.get_dimensional_dependencies(length * length) == {length: 2}
+    assert dimsys_SI.get_dimensional_dependencies(length ** 2) == {length: 2}
+    assert dimsys_SI.get_dimensional_dependencies(length * time) == {length: 1, time: 1}
+    assert dimsys_SI.get_dimensional_dependencies(velo) == {length: 1, time: -1}
+    assert dimsys_SI.get_dimensional_dependencies(velo ** 2) == {length: 2, time: -2}
+
+    assert dimsys_SI.get_dimensional_dependencies(length / length) == {}
+    assert dimsys_SI.get_dimensional_dependencies(velo / length * time) == {}
+    assert dimsys_SI.get_dimensional_dependencies(length ** -1) == {length: -1}
+    assert dimsys_SI.get_dimensional_dependencies(velo ** -1.5) == {length: -1.5, time: 1.5}
+
+    length_a = length**"a"
+    assert dimsys_SI.get_dimensional_dependencies(length_a) == {length: Symbol("a")}
+
+    assert dimsys_SI.get_dimensional_dependencies(length**pi) == {length: pi}
+    assert dimsys_SI.get_dimensional_dependencies(length**(length/length)) == {length: Dimension(1)}
+
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(length**length))
+
+    assert length != 1
+    assert length / length != 1
+
+    length_0 = length ** 0
+    assert dimsys_SI.get_dimensional_dependencies(length_0) == {}
+
+    # issue 18738
+    a = Symbol('a')
+    b = Symbol('b')
+    c = sqrt(a**2 + b**2)
+    c_dim = c.subs({a: length, b: length})
+    assert dimsys_SI.equivalent_dims(c_dim, length)
+
+def test_Dimension_functions():
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(cos(length)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(acos(angle)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(atan2(length, time)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(length)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(100, length)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(length, 10)))
+
+    assert dimsys_SI.get_dimensional_dependencies(pi) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(cos(1)) == {}
+    assert dimsys_SI.get_dimensional_dependencies(cos(angle)) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(atan2(length, length)) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(log(length / length, length / length)) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(Abs(length)) == {length: 1}
+    assert dimsys_SI.get_dimensional_dependencies(Abs(length / length)) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(sqrt(-1)) == {}

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/tests/test_dimensionsystem.py

@@ -0,0 +1,95 @@
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import (Matrix, eye)
+from sympy.physics.units.definitions.dimension_definitions import (
+    action, current, length, mass, time,
+    velocity)
+from sympy.physics.units.dimensions import DimensionSystem
+
+
+def test_extend():
+    ms = DimensionSystem((length, time), (velocity,))
+
+    mks = ms.extend((mass,), (action,))
+
+    res = DimensionSystem((length, time, mass), (velocity, action))
+    assert mks.base_dims == res.base_dims
+    assert mks.derived_dims == res.derived_dims
+
+
+def test_list_dims():
+    dimsys = DimensionSystem((length, time, mass))
+
+    assert dimsys.list_can_dims == (length, mass, time)
+
+
+def test_dim_can_vector():
+    dimsys = DimensionSystem(
+        [length, mass, time],
+        [velocity, action],
+        {
+            velocity: {length: 1, time: -1}
+        }
+    )
+
+    assert dimsys.dim_can_vector(length) == Matrix([1, 0, 0])
+    assert dimsys.dim_can_vector(velocity) == Matrix([1, 0, -1])
+
+    dimsys = DimensionSystem(
+        (length, velocity, action),
+        (mass, time),
+        {
+            time: {length: 1, velocity: -1}
+        }
+    )
+
+    assert dimsys.dim_can_vector(length) == Matrix([0, 1, 0])
+    assert dimsys.dim_can_vector(velocity) == Matrix([0, 0, 1])
+    assert dimsys.dim_can_vector(time) == Matrix([0, 1, -1])
+
+    dimsys = DimensionSystem(
+        (length, mass, time),
+        (velocity, action),
+        {velocity: {length: 1, time: -1},
+         action: {mass: 1, length: 2, time: -1}})
+
+    assert dimsys.dim_vector(length) == Matrix([1, 0, 0])
+    assert dimsys.dim_vector(velocity) == Matrix([1, 0, -1])
+
+
+def test_inv_can_transf_matrix():
+    dimsys = DimensionSystem((length, mass, time))
+    assert dimsys.inv_can_transf_matrix == eye(3)
+
+
+def test_can_transf_matrix():
+    dimsys = DimensionSystem((length, mass, time))
+    assert dimsys.can_transf_matrix == eye(3)
+
+    dimsys = DimensionSystem((length, velocity, action))
+    assert dimsys.can_transf_matrix == eye(3)
+
+    dimsys = DimensionSystem((length, time), (velocity,), {velocity: {length: 1, time: -1}})
+    assert dimsys.can_transf_matrix == eye(2)
+
+
+def test_is_consistent():
+    assert DimensionSystem((length, time)).is_consistent is True
+
+
+def test_print_dim_base():
+    mksa = DimensionSystem(
+        (length, time, mass, current),
+        (action,),
+        {action: {mass: 1, length: 2, time: -1}})
+    L, M, T = symbols("L M T")
+    assert mksa.print_dim_base(action) == L**2*M/T
+
+
+def test_dim():
+    dimsys = DimensionSystem(
+        (length, mass, time),
+        (velocity, action),
+        {velocity: {length: 1, time: -1},
+         action: {mass: 1, length: 2, time: -1}}
+    )
+    assert dimsys.dim == 3

code/LaDi-RL-old-qwen-cod/LaDi-RL-old-qwen-cod/venv/lib64/python3.10/site-packages/sympy/physics/units/tests/test_prefixes.py

@@ -0,0 +1,86 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.physics.units import Quantity, length, meter, W
+from sympy.physics.units.prefixes import PREFIXES, Prefix, prefix_unit, kilo, \
+    kibi
+from sympy.physics.units.systems import SI
+
+x = Symbol('x')
+
+
+def test_prefix_operations():
+    m = PREFIXES['m']
+    k = PREFIXES['k']
+    M = PREFIXES['M']
+
+    dodeca = Prefix('dodeca', 'dd', 1, base=12)
+
+    assert m * k is S.One
+    assert m * W == W / 1000
+    assert k * k == M
+    assert 1 / m == k
+    assert k / m == M
+
+    assert dodeca * dodeca == 144
+    assert 1 / dodeca == S.One / 12
+    assert k / dodeca == S(1000) / 12
+    assert dodeca / dodeca is S.One
+
+    m = Quantity("fake_meter")
+    SI.set_quantity_dimension(m, S.One)
+    SI.set_quantity_scale_factor(m, S.One)
+
+    assert dodeca * m == 12 * m
+    assert dodeca / m == 12 / m
+
+    expr1 = kilo * 3
+    assert isinstance(expr1, Mul)
+    assert expr1.args == (3, kilo)
+
+    expr2 = kilo * x
+    assert isinstance(expr2, Mul)
+    assert expr2.args == (x, kilo)
+
+    expr3 = kilo / 3
+    assert isinstance(expr3, Mul)
+    assert expr3.args == (Rational(1, 3), kilo)
+    assert expr3.args == (S.One/3, kilo)
+
+    expr4 = kilo / x
+    assert isinstance(expr4, Mul)
+    assert expr4.args == (1/x, kilo)
+
+
+def test_prefix_unit():
+    m = Quantity("fake_meter", abbrev="m")
+    m.set_global_relative_scale_factor(1, meter)
+
+    pref = {"m": PREFIXES["m"], "c": PREFIXES["c"], "d": PREFIXES["d"]}
+
+    q1 = Quantity("millifake_meter", abbrev="mm")
+    q2 = Quantity("centifake_meter", abbrev="cm")
+    q3 = Quantity("decifake_meter", abbrev="dm")
+
+    SI.set_quantity_dimension(q1, length)
+
+    SI.set_quantity_scale_factor(q1, PREFIXES["m"])
+    SI.set_quantity_scale_factor(q1, PREFIXES["c"])
+    SI.set_quantity_scale_factor(q1, PREFIXES["d"])
+
+    res = [q1, q2, q3]
+
+    prefs = prefix_unit(m, pref)
+    assert set(prefs) == set(res)
+    assert {v.abbrev for v in prefs} == set(symbols("mm,cm,dm"))
+
+
+def test_bases():
+    assert kilo.base == 10
+    assert kibi.base == 2
+
+
+def test_repr():
+    assert eval(repr(kilo)) == kilo
+    assert eval(repr(kibi)) == kibi