Add files using upload-large-folder tool

.venv/Lib/site-packages/sklearn/datasets/tests/data/openml/id_561/data-v1-dl-52739.arff.gz

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

.venv/Lib/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jd-61.json.gz

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

.venv/Lib/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdf-61.json.gz

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

.venv/Lib/site-packages/sklearn/datasets/tests/data/openml/id_61/api-v1-jdq-61.json.gz

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

.venv/Lib/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jdf-62.json.gz

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

.venv/Lib/site-packages/sklearn/datasets/tests/data/openml/id_62/api-v1-jdq-62.json.gz

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

.venv/Lib/site-packages/sklearn/datasets/tests/data/openml/id_62/data-v1-dl-52352.arff.gz

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

.venv/Lib/site-packages/sympy/physics/quantum/tests/test_operator.py

@@ -0,0 +1,263 @@
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Integer, pi)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.physics.quantum.qexpr import QExpr
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.hilbert import HilbertSpace
+from sympy.physics.quantum.operator import (Operator, UnitaryOperator,
+                                            HermitianOperator, OuterProduct,
+                                            DifferentialOperator,
+                                            IdentityOperator)
+from sympy.physics.quantum.state import Ket, Bra, Wavefunction
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.represent import represent
+from sympy.physics.quantum.spin import JzKet, JzBra
+from sympy.physics.quantum.trace import Tr
+from sympy.matrices import eye
+
+
+class CustomKet(Ket):
+    @classmethod
+    def default_args(self):
+        return ("t",)
+
+
+class CustomOp(HermitianOperator):
+    @classmethod
+    def default_args(self):
+        return ("T",)
+
+t_ket = CustomKet()
+t_op = CustomOp()
+
+
+def test_operator():
+    A = Operator('A')
+    B = Operator('B')
+    C = Operator('C')
+
+    assert isinstance(A, Operator)
+    assert isinstance(A, QExpr)
+
+    assert A.label == (Symbol('A'),)
+    assert A.is_commutative is False
+    assert A.hilbert_space == HilbertSpace()
+
+    assert A*B != B*A
+
+    assert (A*(B + C)).expand() == A*B + A*C
+    assert ((A + B)**2).expand() == A**2 + A*B + B*A + B**2
+
+    assert t_op.label[0] == Symbol(t_op.default_args()[0])
+
+    assert Operator() == Operator("O")
+    assert A*IdentityOperator() == A
+
+
+def test_operator_inv():
+    A = Operator('A')
+    assert A*A.inv() == 1
+    assert A.inv()*A == 1
+
+
+def test_hermitian():
+    H = HermitianOperator('H')
+
+    assert isinstance(H, HermitianOperator)
+    assert isinstance(H, Operator)
+
+    assert Dagger(H) == H
+    assert H.inv() != H
+    assert H.is_commutative is False
+    assert Dagger(H).is_commutative is False
+
+
+def test_unitary():
+    U = UnitaryOperator('U')
+
+    assert isinstance(U, UnitaryOperator)
+    assert isinstance(U, Operator)
+
+    assert U.inv() == Dagger(U)
+    assert U*Dagger(U) == 1
+    assert Dagger(U)*U == 1
+    assert U.is_commutative is False
+    assert Dagger(U).is_commutative is False
+
+
+def test_identity():
+    I = IdentityOperator()
+    O = Operator('O')
+    x = Symbol("x")
+
+    assert isinstance(I, IdentityOperator)
+    assert isinstance(I, Operator)
+
+    assert I * O == O
+    assert O * I == O
+    assert I * Dagger(O) == Dagger(O)
+    assert Dagger(O) * I == Dagger(O)
+    assert isinstance(I * I, IdentityOperator)
+    assert isinstance(3 * I, Mul)
+    assert isinstance(I * x, Mul)
+    assert I.inv() == I
+    assert Dagger(I) == I
+    assert qapply(I * O) == O
+    assert qapply(O * I) == O
+
+    for n in [2, 3, 5]:
+        assert represent(IdentityOperator(n)) == eye(n)
+
+
+def test_outer_product():
+    k = Ket('k')
+    b = Bra('b')
+    op = OuterProduct(k, b)
+
+    assert isinstance(op, OuterProduct)
+    assert isinstance(op, Operator)
+
+    assert op.ket == k
+    assert op.bra == b
+    assert op.label == (k, b)
+    assert op.is_commutative is False
+
+    op = k*b
+
+    assert isinstance(op, OuterProduct)
+    assert isinstance(op, Operator)
+
+    assert op.ket == k
+    assert op.bra == b
+    assert op.label == (k, b)
+    assert op.is_commutative is False
+
+    op = 2*k*b
+
+    assert op == Mul(Integer(2), k, b)
+
+    op = 2*(k*b)
+
+    assert op == Mul(Integer(2), OuterProduct(k, b))
+
+    assert Dagger(k*b) == OuterProduct(Dagger(b), Dagger(k))
+    assert Dagger(k*b).is_commutative is False
+
+    #test the _eval_trace
+    assert Tr(OuterProduct(JzKet(1, 1), JzBra(1, 1))).doit() == 1
+
+    # test scaled kets and bras
+    assert OuterProduct(2 * k, b) == 2 * OuterProduct(k, b)
+    assert OuterProduct(k, 2 * b) == 2 * OuterProduct(k, b)
+
+    # test sums of kets and bras
+    k1, k2 = Ket('k1'), Ket('k2')
+    b1, b2 = Bra('b1'), Bra('b2')
+    assert (OuterProduct(k1 + k2, b1) ==
+            OuterProduct(k1, b1) + OuterProduct(k2, b1))
+    assert (OuterProduct(k1, b1 + b2) ==
+            OuterProduct(k1, b1) + OuterProduct(k1, b2))
+    assert (OuterProduct(1 * k1 + 2 * k2, 3 * b1 + 4 * b2) ==
+            3 * OuterProduct(k1, b1) +
+            4 * OuterProduct(k1, b2) +
+            6 * OuterProduct(k2, b1) +
+            8 * OuterProduct(k2, b2))
+
+
+def test_operator_dagger():
+    A = Operator('A')
+    B = Operator('B')
+    assert Dagger(A*B) == Dagger(B)*Dagger(A)
+    assert Dagger(A + B) == Dagger(A) + Dagger(B)
+    assert Dagger(A**2) == Dagger(A)**2
+
+
+def test_differential_operator():
+    x = Symbol('x')
+    f = Function('f')
+    d = DifferentialOperator(Derivative(f(x), x), f(x))
+    g = Wavefunction(x**2, x)
+    assert qapply(d*g) == Wavefunction(2*x, x)
+    assert d.expr == Derivative(f(x), x)
+    assert d.function == f(x)
+    assert d.variables == (x,)
+    assert diff(d, x) == DifferentialOperator(Derivative(f(x), x, 2), f(x))
+
+    d = DifferentialOperator(Derivative(f(x), x, 2), f(x))
+    g = Wavefunction(x**3, x)
+    assert qapply(d*g) == Wavefunction(6*x, x)
+    assert d.expr == Derivative(f(x), x, 2)
+    assert d.function == f(x)
+    assert d.variables == (x,)
+    assert diff(d, x) == DifferentialOperator(Derivative(f(x), x, 3), f(x))
+
+    d = DifferentialOperator(1/x*Derivative(f(x), x), f(x))
+    assert d.expr == 1/x*Derivative(f(x), x)
+    assert d.function == f(x)
+    assert d.variables == (x,)
+    assert diff(d, x) == \
+        DifferentialOperator(Derivative(1/x*Derivative(f(x), x), x), f(x))
+    assert qapply(d*g) == Wavefunction(3*x, x)
+
+    # 2D cartesian Laplacian
+    y = Symbol('y')
+    d = DifferentialOperator(Derivative(f(x, y), x, 2) +
+                             Derivative(f(x, y), y, 2), f(x, y))
+    w = Wavefunction(x**3*y**2 + y**3*x**2, x, y)
+    assert d.expr == Derivative(f(x, y), x, 2) + Derivative(f(x, y), y, 2)
+    assert d.function == f(x, y)
+    assert d.variables == (x, y)
+    assert diff(d, x) == \
+        DifferentialOperator(Derivative(d.expr, x), f(x, y))
+    assert diff(d, y) == \
+        DifferentialOperator(Derivative(d.expr, y), f(x, y))
+    assert qapply(d*w) == Wavefunction(2*x**3 + 6*x*y**2 + 6*x**2*y + 2*y**3,
+                                       x, y)
+
+    # 2D polar Laplacian (th = theta)
+    r, th = symbols('r th')
+    d = DifferentialOperator(1/r*Derivative(r*Derivative(f(r, th), r), r) +
+                             1/(r**2)*Derivative(f(r, th), th, 2), f(r, th))
+    w = Wavefunction(r**2*sin(th), r, (th, 0, pi))
+    assert d.expr == \
+        1/r*Derivative(r*Derivative(f(r, th), r), r) + \
+        1/(r**2)*Derivative(f(r, th), th, 2)
+    assert d.function == f(r, th)
+    assert d.variables == (r, th)
+    assert diff(d, r) == \
+        DifferentialOperator(Derivative(d.expr, r), f(r, th))
+    assert diff(d, th) == \
+        DifferentialOperator(Derivative(d.expr, th), f(r, th))
+    assert qapply(d*w) == Wavefunction(3*sin(th), r, (th, 0, pi))
+
+
+def test_eval_power():
+    from sympy.core import Pow
+    from sympy.core.expr import unchanged
+    O = Operator('O')
+    U = UnitaryOperator('U')
+    H = HermitianOperator('H')
+    assert O**-1 == O.inv() # same as doc test
+    assert U**-1 == U.inv()
+    assert H**-1 == H.inv()
+    x = symbols("x", commutative = True)
+    assert unchanged(Pow, H, x) # verify Pow(H,x)=="X^n"
+    assert H**x == Pow(H, x)
+    assert Pow(H,x) == Pow(H, x, evaluate=False) # Just check
+    from sympy.physics.quantum.gate import XGate
+    X = XGate(0) # is hermitian and unitary
+    assert unchanged(Pow, X, x) # verify Pow(X,x)=="X^x"
+    assert X**x == Pow(X, x)
+    assert Pow(X, x, evaluate=False) == Pow(X, x) # Just check
+    n = symbols("n", integer=True, even=True)
+    assert X**n == 1
+    n = symbols("n", integer=True, odd=True)
+    assert X**n == X
+    n = symbols("n", integer=True)
+    assert unchanged(Pow, X, n) # verify Pow(X,n)=="X^n"
+    assert X**n == Pow(X, n)
+    assert Pow(X, n, evaluate=False)==Pow(X, n) # Just check
+    assert X**4 == 1
+    assert X**7 == X

.venv/Lib/site-packages/sympy/physics/quantum/tests/test_operatorordering.py

@@ -0,0 +1,50 @@
+from sympy.physics.quantum import Dagger
+from sympy.physics.quantum.boson import BosonOp
+from sympy.physics.quantum.fermion import FermionOp
+from sympy.physics.quantum.operatorordering import (normal_order,
+                                                 normal_ordered_form)
+
+
+def test_normal_order():
+    a = BosonOp('a')
+
+    c = FermionOp('c')
+
+    assert normal_order(a * Dagger(a)) == Dagger(a) * a
+    assert normal_order(Dagger(a) * a) == Dagger(a) * a
+    assert normal_order(a * Dagger(a) ** 2) == Dagger(a) ** 2 * a
+
+    assert normal_order(c * Dagger(c)) == - Dagger(c) * c
+    assert normal_order(Dagger(c) * c) == Dagger(c) * c
+    assert normal_order(c * Dagger(c) ** 2) == Dagger(c) ** 2 * c
+
+
+def test_normal_ordered_form():
+    a = BosonOp('a')
+    b = BosonOp('b')
+
+    c = FermionOp('c')
+    d = FermionOp('d')
+
+    assert normal_ordered_form(Dagger(a) * a) == Dagger(a) * a
+    assert normal_ordered_form(a * Dagger(a)) == 1 + Dagger(a) * a
+    assert normal_ordered_form(a ** 2 * Dagger(a)) == \
+        2 * a + Dagger(a) * a ** 2
+    assert normal_ordered_form(a ** 3 * Dagger(a)) == \
+        3 * a ** 2 + Dagger(a) * a ** 3
+
+    assert normal_ordered_form(Dagger(c) * c) == Dagger(c) * c
+    assert normal_ordered_form(c * Dagger(c)) == 1 - Dagger(c) * c
+    assert normal_ordered_form(c ** 2 * Dagger(c)) == Dagger(c) * c ** 2
+    assert normal_ordered_form(c ** 3 * Dagger(c)) == \
+        c ** 2 - Dagger(c) * c ** 3
+
+    assert normal_ordered_form(a * Dagger(b), True) == Dagger(b) * a
+    assert normal_ordered_form(Dagger(a) * b, True) == Dagger(a) * b
+    assert normal_ordered_form(b * a, True) == a * b
+    assert normal_ordered_form(Dagger(b) * Dagger(a), True) == Dagger(a) * Dagger(b)
+
+    assert normal_ordered_form(c * Dagger(d), True) == -Dagger(d) * c
+    assert normal_ordered_form(Dagger(c) * d, True) == Dagger(c) * d
+    assert normal_ordered_form(d * c, True) == -c * d
+    assert normal_ordered_form(Dagger(d) * Dagger(c), True) == -Dagger(c) * Dagger(d)

.venv/Lib/site-packages/sympy/physics/quantum/tests/test_operatorset.py

@@ -0,0 +1,68 @@
+from sympy.core.singleton import S
+
+from sympy.physics.quantum.operatorset import (
+    operators_to_state, state_to_operators
+)
+
+from sympy.physics.quantum.cartesian import (
+    XOp, XKet, PxOp, PxKet, XBra, PxBra
+)
+
+from sympy.physics.quantum.state import Ket, Bra
+from sympy.physics.quantum.operator import Operator
+from sympy.physics.quantum.spin import (
+    JxKet, JyKet, JzKet, JxBra, JyBra, JzBra,
+    JxOp, JyOp, JzOp, J2Op
+)
+
+from sympy.testing.pytest import raises
+
+
+def test_spin():
+    assert operators_to_state({J2Op, JxOp}) == JxKet
+    assert operators_to_state({J2Op, JyOp}) == JyKet
+    assert operators_to_state({J2Op, JzOp}) == JzKet
+    assert operators_to_state({J2Op(), JxOp()}) == JxKet
+    assert operators_to_state({J2Op(), JyOp()}) == JyKet
+    assert operators_to_state({J2Op(), JzOp()}) == JzKet
+
+    assert state_to_operators(JxKet) == {J2Op, JxOp}
+    assert state_to_operators(JyKet) == {J2Op, JyOp}
+    assert state_to_operators(JzKet) == {J2Op, JzOp}
+    assert state_to_operators(JxBra) == {J2Op, JxOp}
+    assert state_to_operators(JyBra) == {J2Op, JyOp}
+    assert state_to_operators(JzBra) == {J2Op, JzOp}
+
+    assert state_to_operators(JxKet(S.Half, S.Half)) == {J2Op(), JxOp()}
+    assert state_to_operators(JyKet(S.Half, S.Half)) == {J2Op(), JyOp()}
+    assert state_to_operators(JzKet(S.Half, S.Half)) == {J2Op(), JzOp()}
+    assert state_to_operators(JxBra(S.Half, S.Half)) == {J2Op(), JxOp()}
+    assert state_to_operators(JyBra(S.Half, S.Half)) == {J2Op(), JyOp()}
+    assert state_to_operators(JzBra(S.Half, S.Half)) == {J2Op(), JzOp()}
+
+
+def test_op_to_state():
+    assert operators_to_state(XOp) == XKet()
+    assert operators_to_state(PxOp) == PxKet()
+    assert operators_to_state(Operator) == Ket()
+
+    assert state_to_operators(operators_to_state(XOp("Q"))) == XOp("Q")
+    assert state_to_operators(operators_to_state(XOp())) == XOp()
+
+    raises(NotImplementedError, lambda: operators_to_state(XKet))
+
+
+def test_state_to_op():
+    assert state_to_operators(XKet) == XOp()
+    assert state_to_operators(PxKet) == PxOp()
+    assert state_to_operators(XBra) == XOp()
+    assert state_to_operators(PxBra) == PxOp()
+    assert state_to_operators(Ket) == Operator()
+    assert state_to_operators(Bra) == Operator()
+
+    assert operators_to_state(state_to_operators(XKet("test"))) == XKet("test")
+    assert operators_to_state(state_to_operators(XBra("test"))) == XKet("test")
+    assert operators_to_state(state_to_operators(XKet())) == XKet()
+    assert operators_to_state(state_to_operators(XBra())) == XKet()
+
+    raises(NotImplementedError, lambda: state_to_operators(XOp))

.venv/Lib/site-packages/sympy/physics/quantum/tests/test_pauli.py

@@ -0,0 +1,159 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import I
+from sympy.matrices.dense import Matrix
+from sympy.printing.latex import latex
+from sympy.physics.quantum import (Dagger, Commutator, AntiCommutator, qapply,
+                                   Operator, represent)
+from sympy.physics.quantum.pauli import (SigmaOpBase, SigmaX, SigmaY, SigmaZ,
+                                         SigmaMinus, SigmaPlus,
+                                         qsimplify_pauli)
+from sympy.physics.quantum.pauli import SigmaZKet, SigmaZBra
+from sympy.testing.pytest import raises
+
+
+sx, sy, sz = SigmaX(), SigmaY(), SigmaZ()
+sx1, sy1, sz1 = SigmaX(1), SigmaY(1), SigmaZ(1)
+sx2, sy2, sz2 = SigmaX(2), SigmaY(2), SigmaZ(2)
+
+sm, sp = SigmaMinus(), SigmaPlus()
+sm1, sp1 = SigmaMinus(1), SigmaPlus(1)
+A, B = Operator("A"), Operator("B")
+
+
+def test_pauli_operators_types():
+
+    assert isinstance(sx, SigmaOpBase) and isinstance(sx, SigmaX)
+    assert isinstance(sy, SigmaOpBase) and isinstance(sy, SigmaY)
+    assert isinstance(sz, SigmaOpBase) and isinstance(sz, SigmaZ)
+    assert isinstance(sm, SigmaOpBase) and isinstance(sm, SigmaMinus)
+    assert isinstance(sp, SigmaOpBase) and isinstance(sp, SigmaPlus)
+
+
+def test_pauli_operators_commutator():
+
+    assert Commutator(sx, sy).doit() == 2 * I * sz
+    assert Commutator(sy, sz).doit() == 2 * I * sx
+    assert Commutator(sz, sx).doit() == 2 * I * sy
+
+
+def test_pauli_operators_commutator_with_labels():
+
+    assert Commutator(sx1, sy1).doit() == 2 * I * sz1
+    assert Commutator(sy1, sz1).doit() == 2 * I * sx1
+    assert Commutator(sz1, sx1).doit() == 2 * I * sy1
+
+    assert Commutator(sx2, sy2).doit() == 2 * I * sz2
+    assert Commutator(sy2, sz2).doit() == 2 * I * sx2
+    assert Commutator(sz2, sx2).doit() == 2 * I * sy2
+
+    assert Commutator(sx1, sy2).doit() == 0
+    assert Commutator(sy1, sz2).doit() == 0
+    assert Commutator(sz1, sx2).doit() == 0
+
+
+def test_pauli_operators_anticommutator():
+
+    assert AntiCommutator(sy, sz).doit() == 0
+    assert AntiCommutator(sz, sx).doit() == 0
+    assert AntiCommutator(sx, sm).doit() == 1
+    assert AntiCommutator(sx, sp).doit() == 1
+
+
+def test_pauli_operators_adjoint():
+
+    assert Dagger(sx) == sx
+    assert Dagger(sy) == sy
+    assert Dagger(sz) == sz
+
+
+def test_pauli_operators_adjoint_with_labels():
+
+    assert Dagger(sx1) == sx1
+    assert Dagger(sy1) == sy1
+    assert Dagger(sz1) == sz1
+
+    assert Dagger(sx1) != sx2
+    assert Dagger(sy1) != sy2
+    assert Dagger(sz1) != sz2
+
+
+def test_pauli_operators_multiplication():
+
+    assert qsimplify_pauli(sx * sx) == 1
+    assert qsimplify_pauli(sy * sy) == 1
+    assert qsimplify_pauli(sz * sz) == 1
+
+    assert qsimplify_pauli(sx * sy) == I * sz
+    assert qsimplify_pauli(sy * sz) == I * sx
+    assert qsimplify_pauli(sz * sx) == I * sy
+
+    assert qsimplify_pauli(sy * sx) == - I * sz
+    assert qsimplify_pauli(sz * sy) == - I * sx
+    assert qsimplify_pauli(sx * sz) == - I * sy
+
+
+def test_pauli_operators_multiplication_with_labels():
+
+    assert qsimplify_pauli(sx1 * sx1) == 1
+    assert qsimplify_pauli(sy1 * sy1) == 1
+    assert qsimplify_pauli(sz1 * sz1) == 1
+
+    assert isinstance(sx1 * sx2, Mul)
+    assert isinstance(sy1 * sy2, Mul)
+    assert isinstance(sz1 * sz2, Mul)
+
+    assert qsimplify_pauli(sx1 * sy1 * sx2 * sy2) == - sz1 * sz2
+    assert qsimplify_pauli(sy1 * sz1 * sz2 * sx2) == - sx1 * sy2
+
+
+def test_pauli_states():
+    sx, sz = SigmaX(), SigmaZ()
+
+    up = SigmaZKet(0)
+    down = SigmaZKet(1)
+
+    assert qapply(sx * up) == down
+    assert qapply(sx * down) == up
+    assert qapply(sz * up) == up
+    assert qapply(sz * down) == - down
+
+    up = SigmaZBra(0)
+    down = SigmaZBra(1)
+
+    assert qapply(up * sx, dagger=True) == down
+    assert qapply(down * sx, dagger=True) == up
+    assert qapply(up * sz, dagger=True) == up
+    assert qapply(down * sz, dagger=True) == - down
+
+    assert Dagger(SigmaZKet(0)) == SigmaZBra(0)
+    assert Dagger(SigmaZBra(1)) == SigmaZKet(1)
+    raises(ValueError, lambda: SigmaZBra(2))
+    raises(ValueError, lambda: SigmaZKet(2))
+
+
+def test_use_name():
+    assert sm.use_name is False
+    assert sm1.use_name is True
+    assert sx.use_name is False
+    assert sx1.use_name is True
+
+
+def test_printing():
+    assert latex(sx) == r'{\sigma_x}'
+    assert latex(sx1) == r'{\sigma_x^{(1)}}'
+    assert latex(sy) == r'{\sigma_y}'
+    assert latex(sy1) == r'{\sigma_y^{(1)}}'
+    assert latex(sz) == r'{\sigma_z}'
+    assert latex(sz1) == r'{\sigma_z^{(1)}}'
+    assert latex(sm) == r'{\sigma_-}'
+    assert latex(sm1) == r'{\sigma_-^{(1)}}'
+    assert latex(sp) == r'{\sigma_+}'
+    assert latex(sp1) == r'{\sigma_+^{(1)}}'
+
+
+def test_represent():
+    assert represent(sx) == Matrix([[0, 1], [1, 0]])
+    assert represent(sy) == Matrix([[0, -I], [I, 0]])
+    assert represent(sz) == Matrix([[1, 0], [0, -1]])
+    assert represent(sm) == Matrix([[0, 0], [1, 0]])
+    assert represent(sp) == Matrix([[0, 1], [0, 0]])

.venv/Lib/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

.venv/Lib/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')
+    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'))")
+
+
+@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}'

.venv/Lib/site-packages/sympy/physics/quantum/tests/test_qapply.py

@@ -0,0 +1,150 @@
+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
+
+
+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() == TensorProduct(1, 1)
+    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 qapply(P2, dagger = True) == QubitBra(1) # qapply(P1) -> 0 before fix
+    # Pull Request 24237: IdentityOperator from the right without dagger=True option
+    assert qapply(QubitBra(1)*IdentityOperator()) == QubitBra(1)
+    assert qapply(IdentityGate(0)*(Qubit(0) + Qubit(1))) == Qubit(0) + Qubit(1)

.venv/Lib/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))'

.venv/Lib/site-packages/sympy/physics/quantum/tests/test_qexpr.py

@@ -0,0 +1,52 @@
+from sympy.core.numbers import Integer
+from sympy.core.symbol import Symbol
+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')
+
+
+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_commutative_free_symbols():
+    q1 = QExpr(x)
+    assert q1.free_symbols.pop().is_commutative is False
+
+    q2 = QExpr('q2')
+    assert q2.free_symbols.pop().is_commutative is False
+
+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,)

.venv/Lib/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)

.venv/Lib/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():
+    braket = OrthogonalBra(x) * OrthogonalKet(x)
+    assert braket.doit() == 1
+
+    braket = OrthogonalBra(x) * OrthogonalKet(x+1)
+    assert braket.doit() == 0
+
+    braket = OrthogonalBra(x) * OrthogonalKet(y)
+    assert braket.doit() == braket

.venv/Lib/site-packages/sympy/physics/quantum/tests/test_tensorproduct.py

@@ -0,0 +1,137 @@
+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.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
+from sympy.physics.quantum.density import Density
+from sympy.physics.quantum.trace import Tr
+
+A, B, C, D = symbols('A,B,C,D', commutative=False)
+x = symbols('x')
+
+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():
+    assert tensor_product_simp(TP(A, B)*TP(B, C)) == TP(A*B, B*C)
+    # tests for Pow-expressions
+    assert tensor_product_simp(TP(A, B)**x) == TP(A**x, B**x)
+    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)**x) == TP(A,B)-TP(C**x,D**x)
+
+
+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
+
+    A, B, C, D, E, F = symbols('A B C D E F', commutative=False)
+
+    # 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)

.venv/Lib/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

.venv/Lib/site-packages/sympy/physics/tests/test_clebsch_gordan.py

@@ -0,0 +1,198 @@
+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
+
+# 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_wigner():
+    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))
+    # 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)))
+
+
+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()

.venv/Lib/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))

.venv/Lib/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

.venv/Lib/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]])

.venv/Lib/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

.venv/Lib/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))

.venv/Lib/site-packages/sympy/physics/tests/test_secondquant.py

@@ -0,0 +1,1280 @@
+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)'
+
+
+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')
+
+
+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 = symbols('i,j,n,m')
+    o = Bd(i)
+    assert latex(o) == "{b^\\dagger_{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():
+    i, j, n, m = symbols('i,j,n,m')
+    o = B(i)
+    assert latex(o) == "b_{i}"
+    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')
+
+    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}}'
+
+
+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')
+    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}'
+
+
+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))
+
+
+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))

.venv/Lib/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

.venv/Lib/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',
+]

.venv/Lib/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',
+]

.venv/Lib/site-packages/sympy/physics/units/definitions/dimension_definitions.py

@@ -0,0 +1,43 @@
+from sympy.physics.units import Dimension
+
+
+angle = Dimension(name="angle")  # type: Dimension
+
+# 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(name='current', symbol='I')  # type: Dimension
+
+# other base dimensions:
+temperature = Dimension("temperature", "T")  # type: Dimension
+amount_of_substance = Dimension("amount_of_substance")  # type: Dimension
+luminous_intensity = Dimension("luminous_intensity")  # type: Dimension
+
+# 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(name='voltage', symbol='U')  # type: Dimension
+impedance = Dimension(name='impedance', symbol='Z')  # type: Dimension
+conductance = Dimension(name='conductance', symbol='G')  # type: Dimension
+capacitance = Dimension(name='capacitance')  # type: Dimension
+inductance = Dimension(name='inductance')  # type: Dimension
+charge = Dimension(name='charge', symbol='Q')  # type: Dimension
+magnetic_density = Dimension(name='magnetic_density', symbol='B')  # type: Dimension
+magnetic_flux = Dimension(name='magnetic_flux')  # type: Dimension
+
+# Dimensions in information theory:
+information = Dimension(name='information')  # type: Dimension

.venv/Lib/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")

.venv/Lib/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 quantites.
+
+        >>> 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

.venv/Lib/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,
+}

.venv/Lib/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

.venv/Lib/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']

.venv/Lib/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',
+]

.venv/Lib/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',
+]

.venv/Lib/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',
+]

.venv/Lib/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,
+})

.venv/Lib/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")

.venv/Lib/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',
+]

.venv/Lib/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)) == {}

.venv/Lib/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

.venv/Lib/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

.venv/Lib/site-packages/sympy/physics/units/tests/test_quantities.py

@@ -0,0 +1,575 @@
+import warnings
+
+from sympy.core.add import Add
+from sympy.core.function import (Function, diff)
+from sympy.core.numbers import (Number, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import integrate
+from sympy.physics.units import (amount_of_substance, area, convert_to, find_unit,
+                                 volume, kilometer, joule, molar_gas_constant,
+                                 vacuum_permittivity, elementary_charge, volt,
+                                 ohm)
+from sympy.physics.units.definitions import (amu, au, centimeter, coulomb,
+    day, foot, grams, hour, inch, kg, km, m, meter, millimeter,
+    minute, quart, s, second, speed_of_light, bit,
+    byte, kibibyte, mebibyte, gibibyte, tebibyte, pebibyte, exbibyte,
+    kilogram, gravitational_constant, electron_rest_mass)
+
+from sympy.physics.units.definitions.dimension_definitions import (
+    Dimension, charge, length, time, temperature, pressure,
+    energy, mass
+)
+from sympy.physics.units.prefixes import PREFIXES, kilo
+from sympy.physics.units.quantities import PhysicalConstant, Quantity
+from sympy.physics.units.systems import SI
+from sympy.testing.pytest import raises
+
+k = PREFIXES["k"]
+
+
+def test_str_repr():
+    assert str(kg) == "kilogram"
+
+
+def test_eq():
+    # simple test
+    assert 10*m == 10*m
+    assert 10*m != 10*s
+
+
+def test_convert_to():
+    q = Quantity("q1")
+    q.set_global_relative_scale_factor(S(5000), meter)
+
+    assert q.convert_to(m) == 5000*m
+
+    assert speed_of_light.convert_to(m / s) == 299792458 * m / s
+    assert day.convert_to(s) == 86400*s
+
+    # Wrong dimension to convert:
+    assert q.convert_to(s) == q
+    assert speed_of_light.convert_to(m) == speed_of_light
+
+    expr = joule*second
+    conv = convert_to(expr, joule)
+    assert conv == joule*second
+
+
+def test_Quantity_definition():
+    q = Quantity("s10", abbrev="sabbr")
+    q.set_global_relative_scale_factor(10, second)
+    u = Quantity("u", abbrev="dam")
+    u.set_global_relative_scale_factor(10, meter)
+    km = Quantity("km")
+    km.set_global_relative_scale_factor(kilo, meter)
+    v = Quantity("u")
+    v.set_global_relative_scale_factor(5*kilo, meter)
+
+    assert q.scale_factor == 10
+    assert q.dimension == time
+    assert q.abbrev == Symbol("sabbr")
+
+    assert u.dimension == length
+    assert u.scale_factor == 10
+    assert u.abbrev == Symbol("dam")
+
+    assert km.scale_factor == 1000
+    assert km.func(*km.args) == km
+    assert km.func(*km.args).args == km.args
+
+    assert v.dimension == length
+    assert v.scale_factor == 5000
+
+
+def test_abbrev():
+    u = Quantity("u")
+    u.set_global_relative_scale_factor(S.One, meter)
+
+    assert u.name == Symbol("u")
+    assert u.abbrev == Symbol("u")
+
+    u = Quantity("u", abbrev="om")
+    u.set_global_relative_scale_factor(S(2), meter)
+
+    assert u.name == Symbol("u")
+    assert u.abbrev == Symbol("om")
+    assert u.scale_factor == 2
+    assert isinstance(u.scale_factor, Number)
+
+    u = Quantity("u", abbrev="ikm")
+    u.set_global_relative_scale_factor(3*kilo, meter)
+
+    assert u.abbrev == Symbol("ikm")
+    assert u.scale_factor == 3000
+
+
+def test_print():
+    u = Quantity("unitname", abbrev="dam")
+    assert repr(u) == "unitname"
+    assert str(u) == "unitname"
+
+
+def test_Quantity_eq():
+    u = Quantity("u", abbrev="dam")
+    v = Quantity("v1")
+    assert u != v
+    v = Quantity("v2", abbrev="ds")
+    assert u != v
+    v = Quantity("v3", abbrev="dm")
+    assert u != v
+
+
+def test_add_sub():
+    u = Quantity("u")
+    v = Quantity("v")
+    w = Quantity("w")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    w.set_global_relative_scale_factor(S(2), second)
+
+    assert isinstance(u + v, Add)
+    assert (u + v.convert_to(u)) == (1 + S.Half)*u
+    assert isinstance(u - v, Add)
+    assert (u - v.convert_to(u)) == S.Half*u
+
+
+def test_quantity_abs():
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+    v_w3 = Quantity('v_w3')
+
+    v_w1.set_global_relative_scale_factor(1, meter/second)
+    v_w2.set_global_relative_scale_factor(1, meter/second)
+    v_w3.set_global_relative_scale_factor(1, meter/second)
+
+    expr = v_w3 - Abs(v_w1 - v_w2)
+
+    assert SI.get_dimensional_expr(v_w1) == (length/time).name
+
+    Dq = Dimension(SI.get_dimensional_expr(expr))
+
+    assert SI.get_dimension_system().get_dimensional_dependencies(Dq) == {
+        length: 1,
+        time: -1,
+    }
+    assert meter == sqrt(meter**2)
+
+
+def test_check_unit_consistency():
+    u = Quantity("u")
+    v = Quantity("v")
+    w = Quantity("w")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    w.set_global_relative_scale_factor(S(2), second)
+
+    def check_unit_consistency(expr):
+        SI._collect_factor_and_dimension(expr)
+
+    raises(ValueError, lambda: check_unit_consistency(u + w))
+    raises(ValueError, lambda: check_unit_consistency(u - w))
+    raises(ValueError, lambda: check_unit_consistency(u + 1))
+    raises(ValueError, lambda: check_unit_consistency(u - 1))
+    raises(ValueError, lambda: check_unit_consistency(1 - exp(u / w)))
+
+
+def test_mul_div():
+    u = Quantity("u")
+    v = Quantity("v")
+    t = Quantity("t")
+    ut = Quantity("ut")
+    v2 = Quantity("v")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    t.set_global_relative_scale_factor(S(2), second)
+    ut.set_global_relative_scale_factor(S(20), meter*second)
+    v2.set_global_relative_scale_factor(S(5), meter/second)
+
+    assert 1 / u == u**(-1)
+    assert u / 1 == u
+
+    v1 = u / t
+    v2 = v
+
+    # Pow only supports structural equality:
+    assert v1 != v2
+    assert v1 == v2.convert_to(v1)
+
+    # TODO: decide whether to allow such expression in the future
+    # (requires somehow manipulating the core).
+    # assert u / Quantity('l2', dimension=length, scale_factor=2) == 5
+
+    assert u * 1 == u
+
+    ut1 = u * t
+    ut2 = ut
+
+    # Mul only supports structural equality:
+    assert ut1 != ut2
+    assert ut1 == ut2.convert_to(ut1)
+
+    # Mul only supports structural equality:
+    lp1 = Quantity("lp1")
+    lp1.set_global_relative_scale_factor(S(2), 1/meter)
+    assert u * lp1 != 20
+
+    assert u**0 == 1
+    assert u**1 == u
+
+    # TODO: Pow only support structural equality:
+    u2 = Quantity("u2")
+    u3 = Quantity("u3")
+    u2.set_global_relative_scale_factor(S(100), meter**2)
+    u3.set_global_relative_scale_factor(Rational(1, 10), 1/meter)
+
+    assert u ** 2 != u2
+    assert u ** -1 != u3
+
+    assert u ** 2 == u2.convert_to(u)
+    assert u ** -1 == u3.convert_to(u)
+
+
+def test_units():
+    assert convert_to((5*m/s * day) / km, 1) == 432
+    assert convert_to(foot / meter, meter) == Rational(3048, 10000)
+    # amu is a pure mass so mass/mass gives a number, not an amount (mol)
+    # TODO: need better simplification routine:
+    assert str(convert_to(grams/amu, grams).n(2)) == '6.0e+23'
+
+    # Light from the sun needs about 8.3 minutes to reach earth
+    t = (1*au / speed_of_light) / minute
+    # TODO: need a better way to simplify expressions containing units:
+    t = convert_to(convert_to(t, meter / minute), meter)
+    assert t.simplify() == Rational(49865956897, 5995849160)
+
+    # TODO: fix this, it should give `m` without `Abs`
+    assert sqrt(m**2) == m
+    assert (sqrt(m))**2 == m
+
+    t = Symbol('t')
+    assert integrate(t*m/s, (t, 1*s, 5*s)) == 12*m*s
+    assert (t * m/s).integrate((t, 1*s, 5*s)) == 12*m*s
+
+
+def test_issue_quart():
+    assert convert_to(4 * quart / inch ** 3, meter) == 231
+    assert convert_to(4 * quart / inch ** 3, millimeter) == 231
+
+def test_electron_rest_mass():
+    assert convert_to(electron_rest_mass, kilogram) == 9.1093837015e-31*kilogram
+    assert convert_to(electron_rest_mass, grams) == 9.1093837015e-28*grams
+
+def test_issue_5565():
+    assert (m < s).is_Relational
+
+
+def test_find_unit():
+    assert find_unit('coulomb') == ['coulomb', 'coulombs', 'coulomb_constant']
+    assert find_unit(coulomb) == ['C', 'coulomb', 'coulombs', 'planck_charge', 'elementary_charge']
+    assert find_unit(charge) == ['C', 'coulomb', 'coulombs', 'planck_charge', 'elementary_charge']
+    assert find_unit(inch) == [
+        'm', 'au', 'cm', 'dm', 'ft', 'km', 'ly', 'mi', 'mm', 'nm', 'pm', 'um', 'yd',
+        'nmi', 'feet', 'foot', 'inch', 'mile', 'yard', 'meter', 'miles', 'yards',
+        'inches', 'meters', 'micron', 'microns', 'angstrom', 'angstroms', 'decimeter',
+        'kilometer', 'lightyear', 'nanometer', 'picometer', 'centimeter', 'decimeters',
+        'kilometers', 'lightyears', 'micrometer', 'millimeter', 'nanometers', 'picometers',
+        'centimeters', 'micrometers', 'millimeters', 'nautical_mile', 'planck_length',
+        'nautical_miles', 'astronomical_unit', 'astronomical_units']
+    assert find_unit(inch**-1) == ['D', 'dioptre', 'optical_power']
+    assert find_unit(length**-1) == ['D', 'dioptre', 'optical_power']
+    assert find_unit(inch ** 2) == ['ha', 'hectare', 'planck_area']
+    assert find_unit(inch ** 3) == [
+        'L', 'l', 'cL', 'cl', 'dL', 'dl', 'mL', 'ml', 'liter', 'quart', 'liters', 'quarts',
+        'deciliter', 'centiliter', 'deciliters', 'milliliter',
+        'centiliters', 'milliliters', 'planck_volume']
+    assert find_unit('voltage') == ['V', 'v', 'volt', 'volts', 'planck_voltage']
+    assert find_unit(grams) == ['g', 't', 'Da', 'kg', 'me', 'mg', 'ug', 'amu', 'mmu', 'amus',
+                                'gram', 'mmus', 'grams', 'pound', 'tonne', 'dalton', 'pounds',
+                                'kilogram', 'kilograms', 'microgram', 'milligram', 'metric_ton',
+                                'micrograms', 'milligrams', 'planck_mass', 'milli_mass_unit', 'atomic_mass_unit',
+                                'electron_rest_mass', 'atomic_mass_constant']
+
+
+def test_Quantity_derivative():
+    x = symbols("x")
+    assert diff(x*meter, x) == meter
+    assert diff(x**3*meter**2, x) == 3*x**2*meter**2
+    assert diff(meter, meter) == 1
+    assert diff(meter**2, meter) == 2*meter
+
+
+def test_quantity_postprocessing():
+    q1 = Quantity('q1')
+    q2 = Quantity('q2')
+
+    SI.set_quantity_dimension(q1, length*pressure**2*temperature/time)
+    SI.set_quantity_dimension(q2, energy*pressure*temperature/(length**2*time))
+
+    assert q1 + q2
+    q = q1 + q2
+    Dq = Dimension(SI.get_dimensional_expr(q))
+    assert SI.get_dimension_system().get_dimensional_dependencies(Dq) == {
+        length: -1,
+        mass: 2,
+        temperature: 1,
+        time: -5,
+    }
+
+
+def test_factor_and_dimension():
+    assert (3000, Dimension(1)) == SI._collect_factor_and_dimension(3000)
+    assert (1001, length) == SI._collect_factor_and_dimension(meter + km)
+    assert (2, length/time) == SI._collect_factor_and_dimension(
+        meter/second + 36*km/(10*hour))
+
+    x, y = symbols('x y')
+    assert (x + y/100, length) == SI._collect_factor_and_dimension(
+        x*m + y*centimeter)
+
+    cH = Quantity('cH')
+    SI.set_quantity_dimension(cH, amount_of_substance/volume)
+
+    pH = -log(cH)
+
+    assert (1, volume/amount_of_substance) == SI._collect_factor_and_dimension(
+        exp(pH))
+
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+
+    v_w1.set_global_relative_scale_factor(Rational(3, 2), meter/second)
+    v_w2.set_global_relative_scale_factor(2, meter/second)
+
+    expr = Abs(v_w1/2 - v_w2)
+    assert (Rational(5, 4), length/time) == \
+        SI._collect_factor_and_dimension(expr)
+
+    expr = Rational(5, 2)*second/meter*v_w1 - 3000
+    assert (-(2996 + Rational(1, 4)), Dimension(1)) == \
+        SI._collect_factor_and_dimension(expr)
+
+    expr = v_w1**(v_w2/v_w1)
+    assert ((Rational(3, 2))**Rational(4, 3), (length/time)**Rational(4, 3)) == \
+        SI._collect_factor_and_dimension(expr)
+
+
+def test_dimensional_expr_of_derivative():
+    l = Quantity('l')
+    t = Quantity('t')
+    t1 = Quantity('t1')
+    l.set_global_relative_scale_factor(36, km)
+    t.set_global_relative_scale_factor(1, hour)
+    t1.set_global_relative_scale_factor(1, second)
+    x = Symbol('x')
+    y = Symbol('y')
+    f = Function('f')
+    dfdx = f(x, y).diff(x, y)
+    dl_dt = dfdx.subs({f(x, y): l, x: t, y: t1})
+    assert SI.get_dimensional_expr(dl_dt) ==\
+        SI.get_dimensional_expr(l / t / t1) ==\
+        Symbol("length")/Symbol("time")**2
+    assert SI._collect_factor_and_dimension(dl_dt) ==\
+        SI._collect_factor_and_dimension(l / t / t1) ==\
+        (10, length/time**2)
+
+
+def test_get_dimensional_expr_with_function():
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+    v_w1.set_global_relative_scale_factor(1, meter/second)
+    v_w2.set_global_relative_scale_factor(1, meter/second)
+
+    assert SI.get_dimensional_expr(sin(v_w1)) == \
+        sin(SI.get_dimensional_expr(v_w1))
+    assert SI.get_dimensional_expr(sin(v_w1/v_w2)) == 1
+
+
+def test_binary_information():
+    assert convert_to(kibibyte, byte) == 1024*byte
+    assert convert_to(mebibyte, byte) == 1024**2*byte
+    assert convert_to(gibibyte, byte) == 1024**3*byte
+    assert convert_to(tebibyte, byte) == 1024**4*byte
+    assert convert_to(pebibyte, byte) == 1024**5*byte
+    assert convert_to(exbibyte, byte) == 1024**6*byte
+
+    assert kibibyte.convert_to(bit) == 8*1024*bit
+    assert byte.convert_to(bit) == 8*bit
+
+    a = 10*kibibyte*hour
+
+    assert convert_to(a, byte) == 10240*byte*hour
+    assert convert_to(a, minute) == 600*kibibyte*minute
+    assert convert_to(a, [byte, minute]) == 614400*byte*minute
+
+
+def test_conversion_with_2_nonstandard_dimensions():
+    good_grade = Quantity("good_grade")
+    kilo_good_grade = Quantity("kilo_good_grade")
+    centi_good_grade = Quantity("centi_good_grade")
+
+    kilo_good_grade.set_global_relative_scale_factor(1000, good_grade)
+    centi_good_grade.set_global_relative_scale_factor(S.One/10**5, kilo_good_grade)
+
+    charity_points = Quantity("charity_points")
+    milli_charity_points = Quantity("milli_charity_points")
+    missions = Quantity("missions")
+
+    milli_charity_points.set_global_relative_scale_factor(S.One/1000, charity_points)
+    missions.set_global_relative_scale_factor(251, charity_points)
+
+    assert convert_to(
+        kilo_good_grade*milli_charity_points*millimeter,
+        [centi_good_grade, missions, centimeter]
+    ) == S.One * 10**5 / (251*1000) / 10 * centi_good_grade*missions*centimeter
+
+
+def test_eval_subs():
+    energy, mass, force = symbols('energy mass force')
+    expr1 = energy/mass
+    units = {energy: kilogram*meter**2/second**2, mass: kilogram}
+    assert expr1.subs(units) == meter**2/second**2
+    expr2 = force/mass
+    units = {force:gravitational_constant*kilogram**2/meter**2, mass:kilogram}
+    assert expr2.subs(units) == gravitational_constant*kilogram/meter**2
+
+
+def test_issue_14932():
+    assert (log(inch) - log(2)).simplify() == log(inch/2)
+    assert (log(inch) - log(foot)).simplify() == -log(12)
+    p = symbols('p', positive=True)
+    assert (log(inch) - log(p)).simplify() == log(inch/p)
+
+
+def test_issue_14547():
+    # the root issue is that an argument with dimensions should
+    # not raise an error when the `arg - 1` calculation is
+    # performed in the assumptions system
+    from sympy.physics.units import foot, inch
+    from sympy.core.relational import Eq
+    assert log(foot).is_zero is None
+    assert log(foot).is_positive is None
+    assert log(foot).is_nonnegative is None
+    assert log(foot).is_negative is None
+    assert log(foot).is_algebraic is None
+    assert log(foot).is_rational is None
+    # doesn't raise error
+    assert Eq(log(foot), log(inch)) is not None  # might be False or unevaluated
+
+    x = Symbol('x')
+    e = foot + x
+    assert e.is_Add and set(e.args) == {foot, x}
+    e = foot + 1
+    assert e.is_Add and set(e.args) == {foot, 1}
+
+
+def test_issue_22164():
+    warnings.simplefilter("error")
+    dm = Quantity("dm")
+    SI.set_quantity_dimension(dm, length)
+    SI.set_quantity_scale_factor(dm, 1)
+
+    bad_exp = Quantity("bad_exp")
+    SI.set_quantity_dimension(bad_exp, length)
+    SI.set_quantity_scale_factor(bad_exp, 1)
+
+    expr = dm ** bad_exp
+
+    # deprecation warning is not expected here
+    SI._collect_factor_and_dimension(expr)
+
+
+def test_issue_22819():
+    from sympy.physics.units import tonne, gram, Da
+    from sympy.physics.units.systems.si import dimsys_SI
+    assert tonne.convert_to(gram) == 1000000*gram
+    assert dimsys_SI.get_dimensional_dependencies(area) == {length: 2}
+    assert Da.scale_factor == 1.66053906660000e-24
+
+
+def test_issue_20288():
+    from sympy.core.numbers import E
+    from sympy.physics.units import energy
+    u = Quantity('u')
+    v = Quantity('v')
+    SI.set_quantity_dimension(u, energy)
+    SI.set_quantity_dimension(v, energy)
+    u.set_global_relative_scale_factor(1, joule)
+    v.set_global_relative_scale_factor(1, joule)
+    expr = 1 + exp(u**2/v**2)
+    assert SI._collect_factor_and_dimension(expr) == (1 + E, Dimension(1))
+
+
+def test_issue_24062():
+    from sympy.core.numbers import E
+    from sympy.physics.units import impedance, capacitance, time, ohm, farad, second
+
+    R = Quantity('R')
+    C = Quantity('C')
+    T = Quantity('T')
+    SI.set_quantity_dimension(R, impedance)
+    SI.set_quantity_dimension(C, capacitance)
+    SI.set_quantity_dimension(T, time)
+    R.set_global_relative_scale_factor(1, ohm)
+    C.set_global_relative_scale_factor(1, farad)
+    T.set_global_relative_scale_factor(1, second)
+    expr = T / (R * C)
+    dim = SI._collect_factor_and_dimension(expr)[1]
+    assert SI.get_dimension_system().is_dimensionless(dim)
+
+    exp_expr = 1 + exp(expr)
+    assert SI._collect_factor_and_dimension(exp_expr) == (1 + E, Dimension(1))
+
+def test_issue_24211():
+    from sympy.physics.units import time, velocity, acceleration, second, meter
+    V1 = Quantity('V1')
+    SI.set_quantity_dimension(V1, velocity)
+    SI.set_quantity_scale_factor(V1, 1 * meter / second)
+    A1 = Quantity('A1')
+    SI.set_quantity_dimension(A1, acceleration)
+    SI.set_quantity_scale_factor(A1, 1 * meter / second**2)
+    T1 = Quantity('T1')
+    SI.set_quantity_dimension(T1, time)
+    SI.set_quantity_scale_factor(T1, 1 * second)
+
+    expr = A1*T1 + V1
+    # should not throw ValueError here
+    SI._collect_factor_and_dimension(expr)
+
+
+def test_prefixed_property():
+    assert not meter.is_prefixed
+    assert not joule.is_prefixed
+    assert not day.is_prefixed
+    assert not second.is_prefixed
+    assert not volt.is_prefixed
+    assert not ohm.is_prefixed
+    assert centimeter.is_prefixed
+    assert kilometer.is_prefixed
+    assert kilogram.is_prefixed
+    assert pebibyte.is_prefixed
+
+def test_physics_constant():
+    from sympy.physics.units import definitions
+
+    for name in dir(definitions):
+        quantity = getattr(definitions, name)
+        if not isinstance(quantity, Quantity):
+            continue
+        if name.endswith('_constant'):
+            assert isinstance(quantity, PhysicalConstant), f"{quantity} must be PhysicalConstant, but is {type(quantity)}"
+            assert quantity.is_physical_constant, f"{name} is not marked as physics constant when it should be"
+
+    for const in [gravitational_constant, molar_gas_constant, vacuum_permittivity, speed_of_light, elementary_charge]:
+        assert isinstance(const, PhysicalConstant), f"{const} must be PhysicalConstant, but is {type(const)}"
+        assert const.is_physical_constant, f"{const} is not marked as physics constant when it should be"
+
+    assert not meter.is_physical_constant
+    assert not joule.is_physical_constant

.venv/Lib/site-packages/sympy/physics/units/tests/test_unit_system_cgs_gauss.py

@@ -0,0 +1,55 @@
+from sympy.concrete.tests.test_sums_products import NS
+
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.units import convert_to, coulomb_constant, elementary_charge, gravitational_constant, planck
+from sympy.physics.units.definitions.unit_definitions import angstrom, statcoulomb, coulomb, second, gram, centimeter, erg, \
+    newton, joule, dyne, speed_of_light, meter, farad, henry, statvolt, volt, ohm
+from sympy.physics.units.systems import SI
+from sympy.physics.units.systems.cgs import cgs_gauss
+
+
+def test_conversion_to_from_si():
+    assert convert_to(statcoulomb, coulomb, cgs_gauss) == coulomb/2997924580
+    assert convert_to(coulomb, statcoulomb, cgs_gauss) == 2997924580*statcoulomb
+    assert convert_to(statcoulomb, sqrt(gram*centimeter**3)/second, cgs_gauss) == centimeter**(S(3)/2)*sqrt(gram)/second
+    assert convert_to(coulomb, sqrt(gram*centimeter**3)/second, cgs_gauss) == 2997924580*centimeter**(S(3)/2)*sqrt(gram)/second
+
+    # SI units have an additional base unit, no conversion in case of electromagnetism:
+    assert convert_to(coulomb, statcoulomb, SI) == coulomb
+    assert convert_to(statcoulomb, coulomb, SI) == statcoulomb
+
+    # SI without electromagnetism:
+    assert convert_to(erg, joule, SI) == joule/10**7
+    assert convert_to(erg, joule, cgs_gauss) == joule/10**7
+    assert convert_to(joule, erg, SI) == 10**7*erg
+    assert convert_to(joule, erg, cgs_gauss) == 10**7*erg
+
+
+    assert convert_to(dyne, newton, SI) == newton/10**5
+    assert convert_to(dyne, newton, cgs_gauss) == newton/10**5
+    assert convert_to(newton, dyne, SI) == 10**5*dyne
+    assert convert_to(newton, dyne, cgs_gauss) == 10**5*dyne
+
+
+def test_cgs_gauss_convert_constants():
+
+    assert convert_to(speed_of_light, centimeter/second, cgs_gauss) == 29979245800*centimeter/second
+
+    assert convert_to(coulomb_constant, 1, cgs_gauss) == 1
+    assert convert_to(coulomb_constant, newton*meter**2/coulomb**2, cgs_gauss) == 22468879468420441*meter**2*newton/(2500000*coulomb**2)
+    assert convert_to(coulomb_constant, newton*meter**2/coulomb**2, SI) == 22468879468420441*meter**2*newton/(2500000*coulomb**2)
+    assert convert_to(coulomb_constant, dyne*centimeter**2/statcoulomb**2, cgs_gauss) == centimeter**2*dyne/statcoulomb**2
+    assert convert_to(coulomb_constant, 1, SI) == coulomb_constant
+    assert NS(convert_to(coulomb_constant, newton*meter**2/coulomb**2, SI)) == '8987551787.36818*meter**2*newton/coulomb**2'
+
+    assert convert_to(elementary_charge, statcoulomb, cgs_gauss)
+    assert convert_to(angstrom, centimeter, cgs_gauss) == 1*centimeter/10**8
+    assert convert_to(gravitational_constant, dyne*centimeter**2/gram**2, cgs_gauss)
+    assert NS(convert_to(planck, erg*second, cgs_gauss)) == '6.62607015e-27*erg*second'
+
+    spc = 25000*second/(22468879468420441*centimeter)
+    assert convert_to(ohm, second/centimeter, cgs_gauss) == spc
+    assert convert_to(henry, second**2/centimeter, cgs_gauss) == spc*second
+    assert convert_to(volt, statvolt, cgs_gauss) == 10**6*statvolt/299792458
+    assert convert_to(farad, centimeter, cgs_gauss) == 299792458**2*centimeter/10**5