Add files using upload-large-folder tool

ckpts/universal/global_step120/zero/23.attention.dense.weight/exp_avg.pt

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

ckpts/universal/global_step120/zero/23.attention.dense.weight/exp_avg_sq.pt

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

ckpts/universal/global_step120/zero/23.attention.dense.weight/fp32.pt

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

ckpts/universal/global_step120/zero/4.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

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

ckpts/universal/global_step120/zero/4.mlp.dense_4h_to_h.weight/fp32.pt

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

ckpts/universal/global_step80/zero/11.post_attention_layernorm.weight/exp_avg_sq.pt

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

ckpts/universal/global_step80/zero/11.post_attention_layernorm.weight/fp32.pt

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

venv/lib/python3.10/site-packages/sympy/physics/quantum/__init__.py

@@ -0,0 +1,59 @@
+# Names exposed by 'from sympy.physics.quantum import *'
+
+__all__ = [
+    'AntiCommutator',
+
+    'qapply',
+
+    'Commutator',
+
+    'Dagger',
+
+    'HilbertSpaceError', 'HilbertSpace', 'TensorProductHilbertSpace',
+    'TensorPowerHilbertSpace', 'DirectSumHilbertSpace', 'ComplexSpace', 'L2',
+    'FockSpace',
+
+    'InnerProduct',
+
+    'Operator', 'HermitianOperator', 'UnitaryOperator', 'IdentityOperator',
+    'OuterProduct', 'DifferentialOperator',
+
+    'represent', 'rep_innerproduct', 'rep_expectation', 'integrate_result',
+    'get_basis', 'enumerate_states',
+
+    'KetBase', 'BraBase', 'StateBase', 'State', 'Ket', 'Bra', 'TimeDepState',
+    'TimeDepBra', 'TimeDepKet', 'OrthogonalKet', 'OrthogonalBra',
+    'OrthogonalState', 'Wavefunction',
+
+    'TensorProduct', 'tensor_product_simp',
+
+    'hbar', 'HBar',
+
+]
+from .anticommutator import AntiCommutator
+
+from .qapply import qapply
+
+from .commutator import Commutator
+
+from .dagger import Dagger
+
+from .hilbert import (HilbertSpaceError, HilbertSpace,
+        TensorProductHilbertSpace, TensorPowerHilbertSpace,
+        DirectSumHilbertSpace, ComplexSpace, L2, FockSpace)
+
+from .innerproduct import InnerProduct
+
+from .operator import (Operator, HermitianOperator, UnitaryOperator,
+        IdentityOperator, OuterProduct, DifferentialOperator)
+
+from .represent import (represent, rep_innerproduct, rep_expectation,
+        integrate_result, get_basis, enumerate_states)
+
+from .state import (KetBase, BraBase, StateBase, State, Ket, Bra,
+        TimeDepState, TimeDepBra, TimeDepKet, OrthogonalKet,
+        OrthogonalBra, OrthogonalState, Wavefunction)
+
+from .tensorproduct import TensorProduct, tensor_product_simp
+
+from .constants import hbar, HBar

venv/lib/python3.10/site-packages/sympy/physics/quantum/anticommutator.py

@@ -0,0 +1,149 @@
+"""The anti-commutator: ``{A,B} = A*B + B*A``."""
+
+from sympy.core.expr import Expr
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer
+from sympy.core.singleton import S
+from sympy.printing.pretty.stringpict import prettyForm
+
+from sympy.physics.quantum.operator import Operator
+from sympy.physics.quantum.dagger import Dagger
+
+__all__ = [
+    'AntiCommutator'
+]
+
+#-----------------------------------------------------------------------------
+# Anti-commutator
+#-----------------------------------------------------------------------------
+
+
+class AntiCommutator(Expr):
+    """The standard anticommutator, in an unevaluated state.
+
+    Explanation
+    ===========
+
+    Evaluating an anticommutator is defined [1]_ as: ``{A, B} = A*B + B*A``.
+    This class returns the anticommutator in an unevaluated form.  To evaluate
+    the anticommutator, use the ``.doit()`` method.
+
+    Canonical ordering of an anticommutator is ``{A, B}`` for ``A < B``. The
+    arguments of the anticommutator are put into canonical order using
+    ``__cmp__``. If ``B < A``, then ``{A, B}`` is returned as ``{B, A}``.
+
+    Parameters
+    ==========
+
+    A : Expr
+        The first argument of the anticommutator {A,B}.
+    B : Expr
+        The second argument of the anticommutator {A,B}.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.quantum import AntiCommutator
+    >>> from sympy.physics.quantum import Operator, Dagger
+    >>> x, y = symbols('x,y')
+    >>> A = Operator('A')
+    >>> B = Operator('B')
+
+    Create an anticommutator and use ``doit()`` to multiply them out.
+
+    >>> ac = AntiCommutator(A,B); ac
+    {A,B}
+    >>> ac.doit()
+    A*B + B*A
+
+    The commutator orders it arguments in canonical order:
+
+    >>> ac = AntiCommutator(B,A); ac
+    {A,B}
+
+    Commutative constants are factored out:
+
+    >>> AntiCommutator(3*x*A,x*y*B)
+    3*x**2*y*{A,B}
+
+    Adjoint operations applied to the anticommutator are properly applied to
+    the arguments:
+
+    >>> Dagger(AntiCommutator(A,B))
+    {Dagger(A),Dagger(B)}
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Commutator
+    """
+    is_commutative = False
+
+    def __new__(cls, A, B):
+        r = cls.eval(A, B)
+        if r is not None:
+            return r
+        obj = Expr.__new__(cls, A, B)
+        return obj
+
+    @classmethod
+    def eval(cls, a, b):
+        if not (a and b):
+            return S.Zero
+        if a == b:
+            return Integer(2)*a**2
+        if a.is_commutative or b.is_commutative:
+            return Integer(2)*a*b
+
+        # [xA,yB]  ->  xy*[A,B]
+        ca, nca = a.args_cnc()
+        cb, ncb = b.args_cnc()
+        c_part = ca + cb
+        if c_part:
+            return Mul(Mul(*c_part), cls(Mul._from_args(nca), Mul._from_args(ncb)))
+
+        # Canonical ordering of arguments
+        #The Commutator [A,B] is on canonical form if A < B.
+        if a.compare(b) == 1:
+            return cls(b, a)
+
+    def doit(self, **hints):
+        """ Evaluate anticommutator """
+        A = self.args[0]
+        B = self.args[1]
+        if isinstance(A, Operator) and isinstance(B, Operator):
+            try:
+                comm = A._eval_anticommutator(B, **hints)
+            except NotImplementedError:
+                try:
+                    comm = B._eval_anticommutator(A, **hints)
+                except NotImplementedError:
+                    comm = None
+            if comm is not None:
+                return comm.doit(**hints)
+        return (A*B + B*A).doit(**hints)
+
+    def _eval_adjoint(self):
+        return AntiCommutator(Dagger(self.args[0]), Dagger(self.args[1]))
+
+    def _sympyrepr(self, printer, *args):
+        return "%s(%s,%s)" % (
+            self.__class__.__name__, printer._print(
+                self.args[0]), printer._print(self.args[1])
+        )
+
+    def _sympystr(self, printer, *args):
+        return "{%s,%s}" % (
+            printer._print(self.args[0]), printer._print(self.args[1]))
+
+    def _pretty(self, printer, *args):
+        pform = printer._print(self.args[0], *args)
+        pform = prettyForm(*pform.right(prettyForm(',')))
+        pform = prettyForm(*pform.right(printer._print(self.args[1], *args)))
+        pform = prettyForm(*pform.parens(left='{', right='}'))
+        return pform
+
+    def _latex(self, printer, *args):
+        return "\\left\\{%s,%s\\right\\}" % tuple([
+            printer._print(arg, *args) for arg in self.args])

venv/lib/python3.10/site-packages/sympy/physics/quantum/boson.py

@@ -0,0 +1,259 @@
+"""Bosonic quantum operators."""
+
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer
+from sympy.core.singleton import S
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.quantum import Operator
+from sympy.physics.quantum import HilbertSpace, FockSpace, Ket, Bra, IdentityOperator
+from sympy.functions.special.tensor_functions import KroneckerDelta
+
+
+__all__ = [
+    'BosonOp',
+    'BosonFockKet',
+    'BosonFockBra',
+    'BosonCoherentKet',
+    'BosonCoherentBra'
+]
+
+
+class BosonOp(Operator):
+    """A bosonic operator that satisfies [a, Dagger(a)] == 1.
+
+    Parameters
+    ==========
+
+    name : str
+        A string that labels the bosonic mode.
+
+    annihilation : bool
+        A bool that indicates if the bosonic operator is an annihilation (True,
+        default value) or creation operator (False)
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import Dagger, Commutator
+    >>> from sympy.physics.quantum.boson import BosonOp
+    >>> a = BosonOp("a")
+    >>> Commutator(a, Dagger(a)).doit()
+    1
+    """
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def is_annihilation(self):
+        return bool(self.args[1])
+
+    @classmethod
+    def default_args(self):
+        return ("a", True)
+
+    def __new__(cls, *args, **hints):
+        if not len(args) in [1, 2]:
+            raise ValueError('1 or 2 parameters expected, got %s' % args)
+
+        if len(args) == 1:
+            args = (args[0], S.One)
+
+        if len(args) == 2:
+            args = (args[0], Integer(args[1]))
+
+        return Operator.__new__(cls, *args)
+
+    def _eval_commutator_BosonOp(self, other, **hints):
+        if self.name == other.name:
+            # [a^\dagger, a] = -1
+            if not self.is_annihilation and other.is_annihilation:
+                return S.NegativeOne
+
+        elif 'independent' in hints and hints['independent']:
+            # [a, b] = 0
+            return S.Zero
+
+        return None
+
+    def _eval_commutator_FermionOp(self, other, **hints):
+        return S.Zero
+
+    def _eval_anticommutator_BosonOp(self, other, **hints):
+        if 'independent' in hints and hints['independent']:
+            # {a, b} = 2 * a * b, because [a, b] = 0
+            return 2 * self * other
+
+        return None
+
+    def _eval_adjoint(self):
+        return BosonOp(str(self.name), not self.is_annihilation)
+
+    def __mul__(self, other):
+
+        if other == IdentityOperator(2):
+            return self
+
+        if isinstance(other, Mul):
+            args1 = tuple(arg for arg in other.args if arg.is_commutative)
+            args2 = tuple(arg for arg in other.args if not arg.is_commutative)
+            x = self
+            for y in args2:
+                x = x * y
+            return Mul(*args1) * x
+
+        return Mul(self, other)
+
+    def _print_contents_latex(self, printer, *args):
+        if self.is_annihilation:
+            return r'{%s}' % str(self.name)
+        else:
+            return r'{{%s}^\dagger}' % str(self.name)
+
+    def _print_contents(self, printer, *args):
+        if self.is_annihilation:
+            return r'%s' % str(self.name)
+        else:
+            return r'Dagger(%s)' % str(self.name)
+
+    def _print_contents_pretty(self, printer, *args):
+        from sympy.printing.pretty.stringpict import prettyForm
+        pform = printer._print(self.args[0], *args)
+        if self.is_annihilation:
+            return pform
+        else:
+            return pform**prettyForm('\N{DAGGER}')
+
+
+class BosonFockKet(Ket):
+    """Fock state ket for a bosonic mode.
+
+    Parameters
+    ==========
+
+    n : Number
+        The Fock state number.
+
+    """
+
+    def __new__(cls, n):
+        return Ket.__new__(cls, n)
+
+    @property
+    def n(self):
+        return self.label[0]
+
+    @classmethod
+    def dual_class(self):
+        return BosonFockBra
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return FockSpace()
+
+    def _eval_innerproduct_BosonFockBra(self, bra, **hints):
+        return KroneckerDelta(self.n, bra.n)
+
+    def _apply_from_right_to_BosonOp(self, op, **options):
+        if op.is_annihilation:
+            return sqrt(self.n) * BosonFockKet(self.n - 1)
+        else:
+            return sqrt(self.n + 1) * BosonFockKet(self.n + 1)
+
+
+class BosonFockBra(Bra):
+    """Fock state bra for a bosonic mode.
+
+    Parameters
+    ==========
+
+    n : Number
+        The Fock state number.
+
+    """
+
+    def __new__(cls, n):
+        return Bra.__new__(cls, n)
+
+    @property
+    def n(self):
+        return self.label[0]
+
+    @classmethod
+    def dual_class(self):
+        return BosonFockKet
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return FockSpace()
+
+
+class BosonCoherentKet(Ket):
+    """Coherent state ket for a bosonic mode.
+
+    Parameters
+    ==========
+
+    alpha : Number, Symbol
+        The complex amplitude of the coherent state.
+
+    """
+
+    def __new__(cls, alpha):
+        return Ket.__new__(cls, alpha)
+
+    @property
+    def alpha(self):
+        return self.label[0]
+
+    @classmethod
+    def dual_class(self):
+        return BosonCoherentBra
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return HilbertSpace()
+
+    def _eval_innerproduct_BosonCoherentBra(self, bra, **hints):
+        if self.alpha == bra.alpha:
+            return S.One
+        else:
+            return exp(-(abs(self.alpha)**2 + abs(bra.alpha)**2 - 2 * conjugate(bra.alpha) * self.alpha)/2)
+
+    def _apply_from_right_to_BosonOp(self, op, **options):
+        if op.is_annihilation:
+            return self.alpha * self
+        else:
+            return None
+
+
+class BosonCoherentBra(Bra):
+    """Coherent state bra for a bosonic mode.
+
+    Parameters
+    ==========
+
+    alpha : Number, Symbol
+        The complex amplitude of the coherent state.
+
+    """
+
+    def __new__(cls, alpha):
+        return Bra.__new__(cls, alpha)
+
+    @property
+    def alpha(self):
+        return self.label[0]
+
+    @classmethod
+    def dual_class(self):
+        return BosonCoherentKet
+
+    def _apply_operator_BosonOp(self, op, **options):
+        if not op.is_annihilation:
+            return self.alpha * self
+        else:
+            return None

venv/lib/python3.10/site-packages/sympy/physics/quantum/cg.py

@@ -0,0 +1,754 @@
+#TODO:
+# -Implement Clebsch-Gordan symmetries
+# -Improve simplification method
+# -Implement new simplifications
+"""Clebsch-Gordon Coefficients."""
+
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.function import expand
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Wild, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.printing.pretty.stringpict import prettyForm, stringPict
+
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.physics.wigner import clebsch_gordan, wigner_3j, wigner_6j, wigner_9j
+from sympy.printing.precedence import PRECEDENCE
+
+__all__ = [
+    'CG',
+    'Wigner3j',
+    'Wigner6j',
+    'Wigner9j',
+    'cg_simp'
+]
+
+#-----------------------------------------------------------------------------
+# CG Coefficients
+#-----------------------------------------------------------------------------
+
+
+class Wigner3j(Expr):
+    """Class for the Wigner-3j symbols.
+
+    Explanation
+    ===========
+
+    Wigner 3j-symbols are coefficients determined by the coupling of
+    two angular momenta. When created, they are expressed as symbolic
+    quantities that, for numerical parameters, can be evaluated using the
+    ``.doit()`` method [1]_.
+
+    Parameters
+    ==========
+
+    j1, m1, j2, m2, j3, m3 : Number, Symbol
+        Terms determining the angular momentum of coupled angular momentum
+        systems.
+
+    Examples
+    ========
+
+    Declare a Wigner-3j coefficient and calculate its value
+
+        >>> from sympy.physics.quantum.cg import Wigner3j
+        >>> w3j = Wigner3j(6,0,4,0,2,0)
+        >>> w3j
+        Wigner3j(6, 0, 4, 0, 2, 0)
+        >>> w3j.doit()
+        sqrt(715)/143
+
+    See Also
+    ========
+
+    CG: Clebsch-Gordan coefficients
+
+    References
+    ==========
+
+    .. [1] Varshalovich, D A, Quantum Theory of Angular Momentum. 1988.
+    """
+
+    is_commutative = True
+
+    def __new__(cls, j1, m1, j2, m2, j3, m3):
+        args = map(sympify, (j1, m1, j2, m2, j3, m3))
+        return Expr.__new__(cls, *args)
+
+    @property
+    def j1(self):
+        return self.args[0]
+
+    @property
+    def m1(self):
+        return self.args[1]
+
+    @property
+    def j2(self):
+        return self.args[2]
+
+    @property
+    def m2(self):
+        return self.args[3]
+
+    @property
+    def j3(self):
+        return self.args[4]
+
+    @property
+    def m3(self):
+        return self.args[5]
+
+    @property
+    def is_symbolic(self):
+        return not all(arg.is_number for arg in self.args)
+
+    # This is modified from the _print_Matrix method
+    def _pretty(self, printer, *args):
+        m = ((printer._print(self.j1), printer._print(self.m1)),
+            (printer._print(self.j2), printer._print(self.m2)),
+            (printer._print(self.j3), printer._print(self.m3)))
+        hsep = 2
+        vsep = 1
+        maxw = [-1]*3
+        for j in range(3):
+            maxw[j] = max([ m[j][i].width() for i in range(2) ])
+        D = None
+        for i in range(2):
+            D_row = None
+            for j in range(3):
+                s = m[j][i]
+                wdelta = maxw[j] - s.width()
+                wleft = wdelta //2
+                wright = wdelta - wleft
+
+                s = prettyForm(*s.right(' '*wright))
+                s = prettyForm(*s.left(' '*wleft))
+
+                if D_row is None:
+                    D_row = s
+                    continue
+                D_row = prettyForm(*D_row.right(' '*hsep))
+                D_row = prettyForm(*D_row.right(s))
+            if D is None:
+                D = D_row
+                continue
+            for _ in range(vsep):
+                D = prettyForm(*D.below(' '))
+            D = prettyForm(*D.below(D_row))
+        D = prettyForm(*D.parens())
+        return D
+
+    def _latex(self, printer, *args):
+        label = map(printer._print, (self.j1, self.j2, self.j3,
+                    self.m1, self.m2, self.m3))
+        return r'\left(\begin{array}{ccc} %s & %s & %s \\ %s & %s & %s \end{array}\right)' % \
+            tuple(label)
+
+    def doit(self, **hints):
+        if self.is_symbolic:
+            raise ValueError("Coefficients must be numerical")
+        return wigner_3j(self.j1, self.j2, self.j3, self.m1, self.m2, self.m3)
+
+
+class CG(Wigner3j):
+    r"""Class for Clebsch-Gordan coefficient.
+
+    Explanation
+    ===========
+
+    Clebsch-Gordan coefficients describe the angular momentum coupling between
+    two systems. The coefficients give the expansion of a coupled total angular
+    momentum state and an uncoupled tensor product state. The Clebsch-Gordan
+    coefficients are defined as [1]_:
+
+    .. math ::
+        C^{j_3,m_3}_{j_1,m_1,j_2,m_2} = \left\langle j_1,m_1;j_2,m_2 | j_3,m_3\right\rangle
+
+    Parameters
+    ==========
+
+    j1, m1, j2, m2 : Number, Symbol
+        Angular momenta of states 1 and 2.
+
+    j3, m3: Number, Symbol
+        Total angular momentum of the coupled system.
+
+    Examples
+    ========
+
+    Define a Clebsch-Gordan coefficient and evaluate its value
+
+        >>> from sympy.physics.quantum.cg import CG
+        >>> from sympy import S
+        >>> cg = CG(S(3)/2, S(3)/2, S(1)/2, -S(1)/2, 1, 1)
+        >>> cg
+        CG(3/2, 3/2, 1/2, -1/2, 1, 1)
+        >>> cg.doit()
+        sqrt(3)/2
+        >>> CG(j1=S(1)/2, m1=-S(1)/2, j2=S(1)/2, m2=+S(1)/2, j3=1, m3=0).doit()
+        sqrt(2)/2
+
+
+    Compare [2]_.
+
+    See Also
+    ========
+
+    Wigner3j: Wigner-3j symbols
+
+    References
+    ==========
+
+    .. [1] Varshalovich, D A, Quantum Theory of Angular Momentum. 1988.
+    .. [2] `Clebsch-Gordan Coefficients, Spherical Harmonics, and d Functions
+        <https://pdg.lbl.gov/2020/reviews/rpp2020-rev-clebsch-gordan-coefs.pdf>`_
+        in P.A. Zyla *et al.* (Particle Data Group), Prog. Theor. Exp. Phys.
+        2020, 083C01 (2020).
+    """
+    precedence = PRECEDENCE["Pow"] - 1
+
+    def doit(self, **hints):
+        if self.is_symbolic:
+            raise ValueError("Coefficients must be numerical")
+        return clebsch_gordan(self.j1, self.j2, self.j3, self.m1, self.m2, self.m3)
+
+    def _pretty(self, printer, *args):
+        bot = printer._print_seq(
+            (self.j1, self.m1, self.j2, self.m2), delimiter=',')
+        top = printer._print_seq((self.j3, self.m3), delimiter=',')
+
+        pad = max(top.width(), bot.width())
+        bot = prettyForm(*bot.left(' '))
+        top = prettyForm(*top.left(' '))
+
+        if not pad == bot.width():
+            bot = prettyForm(*bot.right(' '*(pad - bot.width())))
+        if not pad == top.width():
+            top = prettyForm(*top.right(' '*(pad - top.width())))
+        s = stringPict('C' + ' '*pad)
+        s = prettyForm(*s.below(bot))
+        s = prettyForm(*s.above(top))
+        return s
+
+    def _latex(self, printer, *args):
+        label = map(printer._print, (self.j3, self.m3, self.j1,
+                    self.m1, self.j2, self.m2))
+        return r'C^{%s,%s}_{%s,%s,%s,%s}' % tuple(label)
+
+
+class Wigner6j(Expr):
+    """Class for the Wigner-6j symbols
+
+    See Also
+    ========
+
+    Wigner3j: Wigner-3j symbols
+
+    """
+    def __new__(cls, j1, j2, j12, j3, j, j23):
+        args = map(sympify, (j1, j2, j12, j3, j, j23))
+        return Expr.__new__(cls, *args)
+
+    @property
+    def j1(self):
+        return self.args[0]
+
+    @property
+    def j2(self):
+        return self.args[1]
+
+    @property
+    def j12(self):
+        return self.args[2]
+
+    @property
+    def j3(self):
+        return self.args[3]
+
+    @property
+    def j(self):
+        return self.args[4]
+
+    @property
+    def j23(self):
+        return self.args[5]
+
+    @property
+    def is_symbolic(self):
+        return not all(arg.is_number for arg in self.args)
+
+    # This is modified from the _print_Matrix method
+    def _pretty(self, printer, *args):
+        m = ((printer._print(self.j1), printer._print(self.j3)),
+            (printer._print(self.j2), printer._print(self.j)),
+            (printer._print(self.j12), printer._print(self.j23)))
+        hsep = 2
+        vsep = 1
+        maxw = [-1]*3
+        for j in range(3):
+            maxw[j] = max([ m[j][i].width() for i in range(2) ])
+        D = None
+        for i in range(2):
+            D_row = None
+            for j in range(3):
+                s = m[j][i]
+                wdelta = maxw[j] - s.width()
+                wleft = wdelta //2
+                wright = wdelta - wleft
+
+                s = prettyForm(*s.right(' '*wright))
+                s = prettyForm(*s.left(' '*wleft))
+
+                if D_row is None:
+                    D_row = s
+                    continue
+                D_row = prettyForm(*D_row.right(' '*hsep))
+                D_row = prettyForm(*D_row.right(s))
+            if D is None:
+                D = D_row
+                continue
+            for _ in range(vsep):
+                D = prettyForm(*D.below(' '))
+            D = prettyForm(*D.below(D_row))
+        D = prettyForm(*D.parens(left='{', right='}'))
+        return D
+
+    def _latex(self, printer, *args):
+        label = map(printer._print, (self.j1, self.j2, self.j12,
+                    self.j3, self.j, self.j23))
+        return r'\left\{\begin{array}{ccc} %s & %s & %s \\ %s & %s & %s \end{array}\right\}' % \
+            tuple(label)
+
+    def doit(self, **hints):
+        if self.is_symbolic:
+            raise ValueError("Coefficients must be numerical")
+        return wigner_6j(self.j1, self.j2, self.j12, self.j3, self.j, self.j23)
+
+
+class Wigner9j(Expr):
+    """Class for the Wigner-9j symbols
+
+    See Also
+    ========
+
+    Wigner3j: Wigner-3j symbols
+
+    """
+    def __new__(cls, j1, j2, j12, j3, j4, j34, j13, j24, j):
+        args = map(sympify, (j1, j2, j12, j3, j4, j34, j13, j24, j))
+        return Expr.__new__(cls, *args)
+
+    @property
+    def j1(self):
+        return self.args[0]
+
+    @property
+    def j2(self):
+        return self.args[1]
+
+    @property
+    def j12(self):
+        return self.args[2]
+
+    @property
+    def j3(self):
+        return self.args[3]
+
+    @property
+    def j4(self):
+        return self.args[4]
+
+    @property
+    def j34(self):
+        return self.args[5]
+
+    @property
+    def j13(self):
+        return self.args[6]
+
+    @property
+    def j24(self):
+        return self.args[7]
+
+    @property
+    def j(self):
+        return self.args[8]
+
+    @property
+    def is_symbolic(self):
+        return not all(arg.is_number for arg in self.args)
+
+    # This is modified from the _print_Matrix method
+    def _pretty(self, printer, *args):
+        m = (
+            (printer._print(
+                self.j1), printer._print(self.j3), printer._print(self.j13)),
+            (printer._print(
+                self.j2), printer._print(self.j4), printer._print(self.j24)),
+            (printer._print(self.j12), printer._print(self.j34), printer._print(self.j)))
+        hsep = 2
+        vsep = 1
+        maxw = [-1]*3
+        for j in range(3):
+            maxw[j] = max([ m[j][i].width() for i in range(3) ])
+        D = None
+        for i in range(3):
+            D_row = None
+            for j in range(3):
+                s = m[j][i]
+                wdelta = maxw[j] - s.width()
+                wleft = wdelta //2
+                wright = wdelta - wleft
+
+                s = prettyForm(*s.right(' '*wright))
+                s = prettyForm(*s.left(' '*wleft))
+
+                if D_row is None:
+                    D_row = s
+                    continue
+                D_row = prettyForm(*D_row.right(' '*hsep))
+                D_row = prettyForm(*D_row.right(s))
+            if D is None:
+                D = D_row
+                continue
+            for _ in range(vsep):
+                D = prettyForm(*D.below(' '))
+            D = prettyForm(*D.below(D_row))
+        D = prettyForm(*D.parens(left='{', right='}'))
+        return D
+
+    def _latex(self, printer, *args):
+        label = map(printer._print, (self.j1, self.j2, self.j12, self.j3,
+                self.j4, self.j34, self.j13, self.j24, self.j))
+        return r'\left\{\begin{array}{ccc} %s & %s & %s \\ %s & %s & %s \\ %s & %s & %s \end{array}\right\}' % \
+            tuple(label)
+
+    def doit(self, **hints):
+        if self.is_symbolic:
+            raise ValueError("Coefficients must be numerical")
+        return wigner_9j(self.j1, self.j2, self.j12, self.j3, self.j4, self.j34, self.j13, self.j24, self.j)
+
+
+def cg_simp(e):
+    """Simplify and combine CG coefficients.
+
+    Explanation
+    ===========
+
+    This function uses various symmetry and properties of sums and
+    products of Clebsch-Gordan coefficients to simplify statements
+    involving these terms [1]_.
+
+    Examples
+    ========
+
+    Simplify the sum over CG(a,alpha,0,0,a,alpha) for all alpha to
+    2*a+1
+
+        >>> from sympy.physics.quantum.cg import CG, cg_simp
+        >>> a = CG(1,1,0,0,1,1)
+        >>> b = CG(1,0,0,0,1,0)
+        >>> c = CG(1,-1,0,0,1,-1)
+        >>> cg_simp(a+b+c)
+        3
+
+    See Also
+    ========
+
+    CG: Clebsh-Gordan coefficients
+
+    References
+    ==========
+
+    .. [1] Varshalovich, D A, Quantum Theory of Angular Momentum. 1988.
+    """
+    if isinstance(e, Add):
+        return _cg_simp_add(e)
+    elif isinstance(e, Sum):
+        return _cg_simp_sum(e)
+    elif isinstance(e, Mul):
+        return Mul(*[cg_simp(arg) for arg in e.args])
+    elif isinstance(e, Pow):
+        return Pow(cg_simp(e.base), e.exp)
+    else:
+        return e
+
+
+def _cg_simp_add(e):
+    #TODO: Improve simplification method
+    """Takes a sum of terms involving Clebsch-Gordan coefficients and
+    simplifies the terms.
+
+    Explanation
+    ===========
+
+    First, we create two lists, cg_part, which is all the terms involving CG
+    coefficients, and other_part, which is all other terms. The cg_part list
+    is then passed to the simplification methods, which return the new cg_part
+    and any additional terms that are added to other_part
+    """
+    cg_part = []
+    other_part = []
+
+    e = expand(e)
+    for arg in e.args:
+        if arg.has(CG):
+            if isinstance(arg, Sum):
+                other_part.append(_cg_simp_sum(arg))
+            elif isinstance(arg, Mul):
+                terms = 1
+                for term in arg.args:
+                    if isinstance(term, Sum):
+                        terms *= _cg_simp_sum(term)
+                    else:
+                        terms *= term
+                if terms.has(CG):
+                    cg_part.append(terms)
+                else:
+                    other_part.append(terms)
+            else:
+                cg_part.append(arg)
+        else:
+            other_part.append(arg)
+
+    cg_part, other = _check_varsh_871_1(cg_part)
+    other_part.append(other)
+    cg_part, other = _check_varsh_871_2(cg_part)
+    other_part.append(other)
+    cg_part, other = _check_varsh_872_9(cg_part)
+    other_part.append(other)
+    return Add(*cg_part) + Add(*other_part)
+
+
+def _check_varsh_871_1(term_list):
+    # Sum( CG(a,alpha,b,0,a,alpha), (alpha, -a, a)) == KroneckerDelta(b,0)
+    a, alpha, b, lt = map(Wild, ('a', 'alpha', 'b', 'lt'))
+    expr = lt*CG(a, alpha, b, 0, a, alpha)
+    simp = (2*a + 1)*KroneckerDelta(b, 0)
+    sign = lt/abs(lt)
+    build_expr = 2*a + 1
+    index_expr = a + alpha
+    return _check_cg_simp(expr, simp, sign, lt, term_list, (a, alpha, b, lt), (a, b), build_expr, index_expr)
+
+
+def _check_varsh_871_2(term_list):
+    # Sum((-1)**(a-alpha)*CG(a,alpha,a,-alpha,c,0),(alpha,-a,a))
+    a, alpha, c, lt = map(Wild, ('a', 'alpha', 'c', 'lt'))
+    expr = lt*CG(a, alpha, a, -alpha, c, 0)
+    simp = sqrt(2*a + 1)*KroneckerDelta(c, 0)
+    sign = (-1)**(a - alpha)*lt/abs(lt)
+    build_expr = 2*a + 1
+    index_expr = a + alpha
+    return _check_cg_simp(expr, simp, sign, lt, term_list, (a, alpha, c, lt), (a, c), build_expr, index_expr)
+
+
+def _check_varsh_872_9(term_list):
+    # Sum( CG(a,alpha,b,beta,c,gamma)*CG(a,alpha',b,beta',c,gamma), (gamma, -c, c), (c, abs(a-b), a+b))
+    a, alpha, alphap, b, beta, betap, c, gamma, lt = map(Wild, (
+        'a', 'alpha', 'alphap', 'b', 'beta', 'betap', 'c', 'gamma', 'lt'))
+    # Case alpha==alphap, beta==betap
+
+    # For numerical alpha,beta
+    expr = lt*CG(a, alpha, b, beta, c, gamma)**2
+    simp = S.One
+    sign = lt/abs(lt)
+    x = abs(a - b)
+    y = abs(alpha + beta)
+    build_expr = a + b + 1 - Piecewise((x, x > y), (0, Eq(x, y)), (y, y > x))
+    index_expr = a + b - c
+    term_list, other1 = _check_cg_simp(expr, simp, sign, lt, term_list, (a, alpha, b, beta, c, gamma, lt), (a, alpha, b, beta), build_expr, index_expr)
+
+    # For symbolic alpha,beta
+    x = abs(a - b)
+    y = a + b
+    build_expr = (y + 1 - x)*(x + y + 1)
+    index_expr = (c - x)*(x + c) + c + gamma
+    term_list, other2 = _check_cg_simp(expr, simp, sign, lt, term_list, (a, alpha, b, beta, c, gamma, lt), (a, alpha, b, beta), build_expr, index_expr)
+
+    # Case alpha!=alphap or beta!=betap
+    # Note: this only works with leading term of 1, pattern matching is unable to match when there is a Wild leading term
+    # For numerical alpha,alphap,beta,betap
+    expr = CG(a, alpha, b, beta, c, gamma)*CG(a, alphap, b, betap, c, gamma)
+    simp = KroneckerDelta(alpha, alphap)*KroneckerDelta(beta, betap)
+    sign = S.One
+    x = abs(a - b)
+    y = abs(alpha + beta)
+    build_expr = a + b + 1 - Piecewise((x, x > y), (0, Eq(x, y)), (y, y > x))
+    index_expr = a + b - c
+    term_list, other3 = _check_cg_simp(expr, simp, sign, S.One, term_list, (a, alpha, alphap, b, beta, betap, c, gamma), (a, alpha, alphap, b, beta, betap), build_expr, index_expr)
+
+    # For symbolic alpha,alphap,beta,betap
+    x = abs(a - b)
+    y = a + b
+    build_expr = (y + 1 - x)*(x + y + 1)
+    index_expr = (c - x)*(x + c) + c + gamma
+    term_list, other4 = _check_cg_simp(expr, simp, sign, S.One, term_list, (a, alpha, alphap, b, beta, betap, c, gamma), (a, alpha, alphap, b, beta, betap), build_expr, index_expr)
+
+    return term_list, other1 + other2 + other4
+
+
+def _check_cg_simp(expr, simp, sign, lt, term_list, variables, dep_variables, build_index_expr, index_expr):
+    """ Checks for simplifications that can be made, returning a tuple of the
+    simplified list of terms and any terms generated by simplification.
+
+    Parameters
+    ==========
+
+    expr: expression
+        The expression with Wild terms that will be matched to the terms in
+        the sum
+
+    simp: expression
+        The expression with Wild terms that is substituted in place of the CG
+        terms in the case of simplification
+
+    sign: expression
+        The expression with Wild terms denoting the sign that is on expr that
+        must match
+
+    lt: expression
+        The expression with Wild terms that gives the leading term of the
+        matched expr
+
+    term_list: list
+        A list of all of the terms is the sum to be simplified
+
+    variables: list
+        A list of all the variables that appears in expr
+
+    dep_variables: list
+        A list of the variables that must match for all the terms in the sum,
+        i.e. the dependent variables
+
+    build_index_expr: expression
+        Expression with Wild terms giving the number of elements in cg_index
+
+    index_expr: expression
+        Expression with Wild terms giving the index terms have when storing
+        them to cg_index
+
+    """
+    other_part = 0
+    i = 0
+    while i < len(term_list):
+        sub_1 = _check_cg(term_list[i], expr, len(variables))
+        if sub_1 is None:
+            i += 1
+            continue
+        if not build_index_expr.subs(sub_1).is_number:
+            i += 1
+            continue
+        sub_dep = [(x, sub_1[x]) for x in dep_variables]
+        cg_index = [None]*build_index_expr.subs(sub_1)
+        for j in range(i, len(term_list)):
+            sub_2 = _check_cg(term_list[j], expr.subs(sub_dep), len(variables) - len(dep_variables), sign=(sign.subs(sub_1), sign.subs(sub_dep)))
+            if sub_2 is None:
+                continue
+            if not index_expr.subs(sub_dep).subs(sub_2).is_number:
+                continue
+            cg_index[index_expr.subs(sub_dep).subs(sub_2)] = j, expr.subs(lt, 1).subs(sub_dep).subs(sub_2), lt.subs(sub_2), sign.subs(sub_dep).subs(sub_2)
+        if not any(i is None for i in cg_index):
+            min_lt = min(*[ abs(term[2]) for term in cg_index ])
+            indices = [ term[0] for term in cg_index]
+            indices.sort()
+            indices.reverse()
+            [ term_list.pop(j) for j in indices ]
+            for term in cg_index:
+                if abs(term[2]) > min_lt:
+                    term_list.append( (term[2] - min_lt*term[3])*term[1] )
+            other_part += min_lt*(sign*simp).subs(sub_1)
+        else:
+            i += 1
+    return term_list, other_part
+
+
+def _check_cg(cg_term, expr, length, sign=None):
+    """Checks whether a term matches the given expression"""
+    # TODO: Check for symmetries
+    matches = cg_term.match(expr)
+    if matches is None:
+        return
+    if sign is not None:
+        if not isinstance(sign, tuple):
+            raise TypeError('sign must be a tuple')
+        if not sign[0] == (sign[1]).subs(matches):
+            return
+    if len(matches) == length:
+        return matches
+
+
+def _cg_simp_sum(e):
+    e = _check_varsh_sum_871_1(e)
+    e = _check_varsh_sum_871_2(e)
+    e = _check_varsh_sum_872_4(e)
+    return e
+
+
+def _check_varsh_sum_871_1(e):
+    a = Wild('a')
+    alpha = symbols('alpha')
+    b = Wild('b')
+    match = e.match(Sum(CG(a, alpha, b, 0, a, alpha), (alpha, -a, a)))
+    if match is not None and len(match) == 2:
+        return ((2*a + 1)*KroneckerDelta(b, 0)).subs(match)
+    return e
+
+
+def _check_varsh_sum_871_2(e):
+    a = Wild('a')
+    alpha = symbols('alpha')
+    c = Wild('c')
+    match = e.match(
+        Sum((-1)**(a - alpha)*CG(a, alpha, a, -alpha, c, 0), (alpha, -a, a)))
+    if match is not None and len(match) == 2:
+        return (sqrt(2*a + 1)*KroneckerDelta(c, 0)).subs(match)
+    return e
+
+
+def _check_varsh_sum_872_4(e):
+    alpha = symbols('alpha')
+    beta = symbols('beta')
+    a = Wild('a')
+    b = Wild('b')
+    c = Wild('c')
+    cp = Wild('cp')
+    gamma = Wild('gamma')
+    gammap = Wild('gammap')
+    cg1 = CG(a, alpha, b, beta, c, gamma)
+    cg2 = CG(a, alpha, b, beta, cp, gammap)
+    match1 = e.match(Sum(cg1*cg2, (alpha, -a, a), (beta, -b, b)))
+    if match1 is not None and len(match1) == 6:
+        return (KroneckerDelta(c, cp)*KroneckerDelta(gamma, gammap)).subs(match1)
+    match2 = e.match(Sum(cg1**2, (alpha, -a, a), (beta, -b, b)))
+    if match2 is not None and len(match2) == 4:
+        return S.One
+    return e
+
+
+def _cg_list(term):
+    if isinstance(term, CG):
+        return (term,), 1, 1
+    cg = []
+    coeff = 1
+    if not isinstance(term, (Mul, Pow)):
+        raise NotImplementedError('term must be CG, Add, Mul or Pow')
+    if isinstance(term, Pow) and term.exp.is_number:
+        if term.exp.is_number:
+            [ cg.append(term.base) for _ in range(term.exp) ]
+        else:
+            return (term,), 1, 1
+    if isinstance(term, Mul):
+        for arg in term.args:
+            if isinstance(arg, CG):
+                cg.append(arg)
+            else:
+                coeff *= arg
+        return cg, coeff, coeff/abs(coeff)

venv/lib/python3.10/site-packages/sympy/physics/quantum/circuitplot.py

@@ -0,0 +1,370 @@
+"""Matplotlib based plotting of quantum circuits.
+
+Todo:
+
+* Optimize printing of large circuits.
+* Get this to work with single gates.
+* Do a better job checking the form of circuits to make sure it is a Mul of
+  Gates.
+* Get multi-target gates plotting.
+* Get initial and final states to plot.
+* Get measurements to plot. Might need to rethink measurement as a gate
+  issue.
+* Get scale and figsize to be handled in a better way.
+* Write some tests/examples!
+"""
+
+from __future__ import annotations
+
+from sympy.core.mul import Mul
+from sympy.external import import_module
+from sympy.physics.quantum.gate import Gate, OneQubitGate, CGate, CGateS
+
+
+__all__ = [
+    'CircuitPlot',
+    'circuit_plot',
+    'labeller',
+    'Mz',
+    'Mx',
+    'CreateOneQubitGate',
+    'CreateCGate',
+]
+
+np = import_module('numpy')
+matplotlib = import_module(
+    'matplotlib', import_kwargs={'fromlist': ['pyplot']},
+    catch=(RuntimeError,))  # This is raised in environments that have no display.
+
+if np and matplotlib:
+    pyplot = matplotlib.pyplot
+    Line2D = matplotlib.lines.Line2D
+    Circle = matplotlib.patches.Circle
+
+#from matplotlib import rc
+#rc('text',usetex=True)
+
+class CircuitPlot:
+    """A class for managing a circuit plot."""
+
+    scale = 1.0
+    fontsize = 20.0
+    linewidth = 1.0
+    control_radius = 0.05
+    not_radius = 0.15
+    swap_delta = 0.05
+    labels: list[str] = []
+    inits: dict[str, str] = {}
+    label_buffer = 0.5
+
+    def __init__(self, c, nqubits, **kwargs):
+        if not np or not matplotlib:
+            raise ImportError('numpy or matplotlib not available.')
+        self.circuit = c
+        self.ngates = len(self.circuit.args)
+        self.nqubits = nqubits
+        self.update(kwargs)
+        self._create_grid()
+        self._create_figure()
+        self._plot_wires()
+        self._plot_gates()
+        self._finish()
+
+    def update(self, kwargs):
+        """Load the kwargs into the instance dict."""
+        self.__dict__.update(kwargs)
+
+    def _create_grid(self):
+        """Create the grid of wires."""
+        scale = self.scale
+        wire_grid = np.arange(0.0, self.nqubits*scale, scale, dtype=float)
+        gate_grid = np.arange(0.0, self.ngates*scale, scale, dtype=float)
+        self._wire_grid = wire_grid
+        self._gate_grid = gate_grid
+
+    def _create_figure(self):
+        """Create the main matplotlib figure."""
+        self._figure = pyplot.figure(
+            figsize=(self.ngates*self.scale, self.nqubits*self.scale),
+            facecolor='w',
+            edgecolor='w'
+        )
+        ax = self._figure.add_subplot(
+            1, 1, 1,
+            frameon=True
+        )
+        ax.set_axis_off()
+        offset = 0.5*self.scale
+        ax.set_xlim(self._gate_grid[0] - offset, self._gate_grid[-1] + offset)
+        ax.set_ylim(self._wire_grid[0] - offset, self._wire_grid[-1] + offset)
+        ax.set_aspect('equal')
+        self._axes = ax
+
+    def _plot_wires(self):
+        """Plot the wires of the circuit diagram."""
+        xstart = self._gate_grid[0]
+        xstop = self._gate_grid[-1]
+        xdata = (xstart - self.scale, xstop + self.scale)
+        for i in range(self.nqubits):
+            ydata = (self._wire_grid[i], self._wire_grid[i])
+            line = Line2D(
+                xdata, ydata,
+                color='k',
+                lw=self.linewidth
+            )
+            self._axes.add_line(line)
+            if self.labels:
+                init_label_buffer = 0
+                if self.inits.get(self.labels[i]): init_label_buffer = 0.25
+                self._axes.text(
+                    xdata[0]-self.label_buffer-init_label_buffer,ydata[0],
+                    render_label(self.labels[i],self.inits),
+                    size=self.fontsize,
+                    color='k',ha='center',va='center')
+        self._plot_measured_wires()
+
+    def _plot_measured_wires(self):
+        ismeasured = self._measurements()
+        xstop = self._gate_grid[-1]
+        dy = 0.04 # amount to shift wires when doubled
+        # Plot doubled wires after they are measured
+        for im in ismeasured:
+            xdata = (self._gate_grid[ismeasured[im]],xstop+self.scale)
+            ydata = (self._wire_grid[im]+dy,self._wire_grid[im]+dy)
+            line = Line2D(
+                xdata, ydata,
+                color='k',
+                lw=self.linewidth
+            )
+            self._axes.add_line(line)
+        # Also double any controlled lines off these wires
+        for i,g in enumerate(self._gates()):
+            if isinstance(g, (CGate, CGateS)):
+                wires = g.controls + g.targets
+                for wire in wires:
+                    if wire in ismeasured and \
+                           self._gate_grid[i] > self._gate_grid[ismeasured[wire]]:
+                        ydata = min(wires), max(wires)
+                        xdata = self._gate_grid[i]-dy, self._gate_grid[i]-dy
+                        line = Line2D(
+                            xdata, ydata,
+                            color='k',
+                            lw=self.linewidth
+                            )
+                        self._axes.add_line(line)
+    def _gates(self):
+        """Create a list of all gates in the circuit plot."""
+        gates = []
+        if isinstance(self.circuit, Mul):
+            for g in reversed(self.circuit.args):
+                if isinstance(g, Gate):
+                    gates.append(g)
+        elif isinstance(self.circuit, Gate):
+            gates.append(self.circuit)
+        return gates
+
+    def _plot_gates(self):
+        """Iterate through the gates and plot each of them."""
+        for i, gate in enumerate(self._gates()):
+            gate.plot_gate(self, i)
+
+    def _measurements(self):
+        """Return a dict ``{i:j}`` where i is the index of the wire that has
+        been measured, and j is the gate where the wire is measured.
+        """
+        ismeasured = {}
+        for i,g in enumerate(self._gates()):
+            if getattr(g,'measurement',False):
+                for target in g.targets:
+                    if target in ismeasured:
+                        if ismeasured[target] > i:
+                            ismeasured[target] = i
+                    else:
+                        ismeasured[target] = i
+        return ismeasured
+
+    def _finish(self):
+        # Disable clipping to make panning work well for large circuits.
+        for o in self._figure.findobj():
+            o.set_clip_on(False)
+
+    def one_qubit_box(self, t, gate_idx, wire_idx):
+        """Draw a box for a single qubit gate."""
+        x = self._gate_grid[gate_idx]
+        y = self._wire_grid[wire_idx]
+        self._axes.text(
+            x, y, t,
+            color='k',
+            ha='center',
+            va='center',
+            bbox={"ec": 'k', "fc": 'w', "fill": True, "lw": self.linewidth},
+            size=self.fontsize
+        )
+
+    def two_qubit_box(self, t, gate_idx, wire_idx):
+        """Draw a box for a two qubit gate. Does not work yet.
+        """
+        # x = self._gate_grid[gate_idx]
+        # y = self._wire_grid[wire_idx]+0.5
+        print(self._gate_grid)
+        print(self._wire_grid)
+        # unused:
+        # obj = self._axes.text(
+        #     x, y, t,
+        #     color='k',
+        #     ha='center',
+        #     va='center',
+        #     bbox=dict(ec='k', fc='w', fill=True, lw=self.linewidth),
+        #     size=self.fontsize
+        # )
+
+    def control_line(self, gate_idx, min_wire, max_wire):
+        """Draw a vertical control line."""
+        xdata = (self._gate_grid[gate_idx], self._gate_grid[gate_idx])
+        ydata = (self._wire_grid[min_wire], self._wire_grid[max_wire])
+        line = Line2D(
+            xdata, ydata,
+            color='k',
+            lw=self.linewidth
+        )
+        self._axes.add_line(line)
+
+    def control_point(self, gate_idx, wire_idx):
+        """Draw a control point."""
+        x = self._gate_grid[gate_idx]
+        y = self._wire_grid[wire_idx]
+        radius = self.control_radius
+        c = Circle(
+            (x, y),
+            radius*self.scale,
+            ec='k',
+            fc='k',
+            fill=True,
+            lw=self.linewidth
+        )
+        self._axes.add_patch(c)
+
+    def not_point(self, gate_idx, wire_idx):
+        """Draw a NOT gates as the circle with plus in the middle."""
+        x = self._gate_grid[gate_idx]
+        y = self._wire_grid[wire_idx]
+        radius = self.not_radius
+        c = Circle(
+            (x, y),
+            radius,
+            ec='k',
+            fc='w',
+            fill=False,
+            lw=self.linewidth
+        )
+        self._axes.add_patch(c)
+        l = Line2D(
+            (x, x), (y - radius, y + radius),
+            color='k',
+            lw=self.linewidth
+        )
+        self._axes.add_line(l)
+
+    def swap_point(self, gate_idx, wire_idx):
+        """Draw a swap point as a cross."""
+        x = self._gate_grid[gate_idx]
+        y = self._wire_grid[wire_idx]
+        d = self.swap_delta
+        l1 = Line2D(
+            (x - d, x + d),
+            (y - d, y + d),
+            color='k',
+            lw=self.linewidth
+        )
+        l2 = Line2D(
+            (x - d, x + d),
+            (y + d, y - d),
+            color='k',
+            lw=self.linewidth
+        )
+        self._axes.add_line(l1)
+        self._axes.add_line(l2)
+
+def circuit_plot(c, nqubits, **kwargs):
+    """Draw the circuit diagram for the circuit with nqubits.
+
+    Parameters
+    ==========
+
+    c : circuit
+        The circuit to plot. Should be a product of Gate instances.
+    nqubits : int
+        The number of qubits to include in the circuit. Must be at least
+        as big as the largest ``min_qubits`` of the gates.
+    """
+    return CircuitPlot(c, nqubits, **kwargs)
+
+def render_label(label, inits={}):
+    """Slightly more flexible way to render labels.
+
+    >>> from sympy.physics.quantum.circuitplot import render_label
+    >>> render_label('q0')
+    '$\\\\left|q0\\\\right\\\\rangle$'
+    >>> render_label('q0', {'q0':'0'})
+    '$\\\\left|q0\\\\right\\\\rangle=\\\\left|0\\\\right\\\\rangle$'
+    """
+    init = inits.get(label)
+    if init:
+        return r'$\left|%s\right\rangle=\left|%s\right\rangle$' % (label, init)
+    return r'$\left|%s\right\rangle$' % label
+
+def labeller(n, symbol='q'):
+    """Autogenerate labels for wires of quantum circuits.
+
+    Parameters
+    ==========
+
+    n : int
+        number of qubits in the circuit.
+    symbol : string
+        A character string to precede all gate labels. E.g. 'q_0', 'q_1', etc.
+
+    >>> from sympy.physics.quantum.circuitplot import labeller
+    >>> labeller(2)
+    ['q_1', 'q_0']
+    >>> labeller(3,'j')
+    ['j_2', 'j_1', 'j_0']
+    """
+    return ['%s_%d' % (symbol,n-i-1) for i in range(n)]
+
+class Mz(OneQubitGate):
+    """Mock-up of a z measurement gate.
+
+    This is in circuitplot rather than gate.py because it's not a real
+    gate, it just draws one.
+    """
+    measurement = True
+    gate_name='Mz'
+    gate_name_latex='M_z'
+
+class Mx(OneQubitGate):
+    """Mock-up of an x measurement gate.
+
+    This is in circuitplot rather than gate.py because it's not a real
+    gate, it just draws one.
+    """
+    measurement = True
+    gate_name='Mx'
+    gate_name_latex='M_x'
+
+class CreateOneQubitGate(type):
+    def __new__(mcl, name, latexname=None):
+        if not latexname:
+            latexname = name
+        return type(name + "Gate", (OneQubitGate,),
+            {'gate_name': name, 'gate_name_latex': latexname})
+
+def CreateCGate(name, latexname=None):
+    """Use a lexical closure to make a controlled gate.
+    """
+    if not latexname:
+        latexname = name
+    onequbitgate = CreateOneQubitGate(name, latexname)
+    def ControlledGate(ctrls,target):
+        return CGate(tuple(ctrls),onequbitgate(target))
+    return ControlledGate

venv/lib/python3.10/site-packages/sympy/physics/quantum/circuitutils.py

@@ -0,0 +1,488 @@
+"""Primitive circuit operations on quantum circuits."""
+
+from functools import reduce
+
+from sympy.core.sorting import default_sort_key
+from sympy.core.containers import Tuple
+from sympy.core.mul import Mul
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.utilities import numbered_symbols
+from sympy.physics.quantum.gate import Gate
+
+__all__ = [
+    'kmp_table',
+    'find_subcircuit',
+    'replace_subcircuit',
+    'convert_to_symbolic_indices',
+    'convert_to_real_indices',
+    'random_reduce',
+    'random_insert'
+]
+
+
+def kmp_table(word):
+    """Build the 'partial match' table of the Knuth-Morris-Pratt algorithm.
+
+    Note: This is applicable to strings or
+    quantum circuits represented as tuples.
+    """
+
+    # Current position in subcircuit
+    pos = 2
+    # Beginning position of candidate substring that
+    # may reappear later in word
+    cnd = 0
+    # The 'partial match' table that helps one determine
+    # the next location to start substring search
+    table = []
+    table.append(-1)
+    table.append(0)
+
+    while pos < len(word):
+        if word[pos - 1] == word[cnd]:
+            cnd = cnd + 1
+            table.append(cnd)
+            pos = pos + 1
+        elif cnd > 0:
+            cnd = table[cnd]
+        else:
+            table.append(0)
+            pos = pos + 1
+
+    return table
+
+
+def find_subcircuit(circuit, subcircuit, start=0, end=0):
+    """Finds the subcircuit in circuit, if it exists.
+
+    Explanation
+    ===========
+
+    If the subcircuit exists, the index of the start of
+    the subcircuit in circuit is returned; otherwise,
+    -1 is returned.  The algorithm that is implemented
+    is the Knuth-Morris-Pratt algorithm.
+
+    Parameters
+    ==========
+
+    circuit : tuple, Gate or Mul
+        A tuple of Gates or Mul representing a quantum circuit
+    subcircuit : tuple, Gate or Mul
+        A tuple of Gates or Mul to find in circuit
+    start : int
+        The location to start looking for subcircuit.
+        If start is the same or past end, -1 is returned.
+    end : int
+        The last place to look for a subcircuit.  If end
+        is less than 1 (one), then the length of circuit
+        is taken to be end.
+
+    Examples
+    ========
+
+    Find the first instance of a subcircuit:
+
+    >>> from sympy.physics.quantum.circuitutils import find_subcircuit
+    >>> from sympy.physics.quantum.gate import X, Y, Z, H
+    >>> circuit = X(0)*Z(0)*Y(0)*H(0)
+    >>> subcircuit = Z(0)*Y(0)
+    >>> find_subcircuit(circuit, subcircuit)
+    1
+
+    Find the first instance starting at a specific position:
+
+    >>> find_subcircuit(circuit, subcircuit, start=1)
+    1
+
+    >>> find_subcircuit(circuit, subcircuit, start=2)
+    -1
+
+    >>> circuit = circuit*subcircuit
+    >>> find_subcircuit(circuit, subcircuit, start=2)
+    4
+
+    Find the subcircuit within some interval:
+
+    >>> find_subcircuit(circuit, subcircuit, start=2, end=2)
+    -1
+    """
+
+    if isinstance(circuit, Mul):
+        circuit = circuit.args
+
+    if isinstance(subcircuit, Mul):
+        subcircuit = subcircuit.args
+
+    if len(subcircuit) == 0 or len(subcircuit) > len(circuit):
+        return -1
+
+    if end < 1:
+        end = len(circuit)
+
+    # Location in circuit
+    pos = start
+    # Location in the subcircuit
+    index = 0
+    # 'Partial match' table
+    table = kmp_table(subcircuit)
+
+    while (pos + index) < end:
+        if subcircuit[index] == circuit[pos + index]:
+            index = index + 1
+        else:
+            pos = pos + index - table[index]
+            index = table[index] if table[index] > -1 else 0
+
+        if index == len(subcircuit):
+            return pos
+
+    return -1
+
+
+def replace_subcircuit(circuit, subcircuit, replace=None, pos=0):
+    """Replaces a subcircuit with another subcircuit in circuit,
+    if it exists.
+
+    Explanation
+    ===========
+
+    If multiple instances of subcircuit exists, the first instance is
+    replaced.  The position to being searching from (if different from
+    0) may be optionally given.  If subcircuit cannot be found, circuit
+    is returned.
+
+    Parameters
+    ==========
+
+    circuit : tuple, Gate or Mul
+        A quantum circuit.
+    subcircuit : tuple, Gate or Mul
+        The circuit to be replaced.
+    replace : tuple, Gate or Mul
+        The replacement circuit.
+    pos : int
+        The location to start search and replace
+        subcircuit, if it exists.  This may be used
+        if it is known beforehand that multiple
+        instances exist, and it is desirable to
+        replace a specific instance.  If a negative number
+        is given, pos will be defaulted to 0.
+
+    Examples
+    ========
+
+    Find and remove the subcircuit:
+
+    >>> from sympy.physics.quantum.circuitutils import replace_subcircuit
+    >>> from sympy.physics.quantum.gate import X, Y, Z, H
+    >>> circuit = X(0)*Z(0)*Y(0)*H(0)*X(0)*H(0)*Y(0)
+    >>> subcircuit = Z(0)*Y(0)
+    >>> replace_subcircuit(circuit, subcircuit)
+    (X(0), H(0), X(0), H(0), Y(0))
+
+    Remove the subcircuit given a starting search point:
+
+    >>> replace_subcircuit(circuit, subcircuit, pos=1)
+    (X(0), H(0), X(0), H(0), Y(0))
+
+    >>> replace_subcircuit(circuit, subcircuit, pos=2)
+    (X(0), Z(0), Y(0), H(0), X(0), H(0), Y(0))
+
+    Replace the subcircuit:
+
+    >>> replacement = H(0)*Z(0)
+    >>> replace_subcircuit(circuit, subcircuit, replace=replacement)
+    (X(0), H(0), Z(0), H(0), X(0), H(0), Y(0))
+    """
+
+    if pos < 0:
+        pos = 0
+
+    if isinstance(circuit, Mul):
+        circuit = circuit.args
+
+    if isinstance(subcircuit, Mul):
+        subcircuit = subcircuit.args
+
+    if isinstance(replace, Mul):
+        replace = replace.args
+    elif replace is None:
+        replace = ()
+
+    # Look for the subcircuit starting at pos
+    loc = find_subcircuit(circuit, subcircuit, start=pos)
+
+    # If subcircuit was found
+    if loc > -1:
+        # Get the gates to the left of subcircuit
+        left = circuit[0:loc]
+        # Get the gates to the right of subcircuit
+        right = circuit[loc + len(subcircuit):len(circuit)]
+        # Recombine the left and right side gates into a circuit
+        circuit = left + replace + right
+
+    return circuit
+
+
+def _sympify_qubit_map(mapping):
+    new_map = {}
+    for key in mapping:
+        new_map[key] = sympify(mapping[key])
+    return new_map
+
+
+def convert_to_symbolic_indices(seq, start=None, gen=None, qubit_map=None):
+    """Returns the circuit with symbolic indices and the
+    dictionary mapping symbolic indices to real indices.
+
+    The mapping is 1 to 1 and onto (bijective).
+
+    Parameters
+    ==========
+
+    seq : tuple, Gate/Integer/tuple or Mul
+        A tuple of Gate, Integer, or tuple objects, or a Mul
+    start : Symbol
+        An optional starting symbolic index
+    gen : object
+        An optional numbered symbol generator
+    qubit_map : dict
+        An existing mapping of symbolic indices to real indices
+
+    All symbolic indices have the format 'i#', where # is
+    some number >= 0.
+    """
+
+    if isinstance(seq, Mul):
+        seq = seq.args
+
+    # A numbered symbol generator
+    index_gen = numbered_symbols(prefix='i', start=-1)
+    cur_ndx = next(index_gen)
+
+    # keys are symbolic indices; values are real indices
+    ndx_map = {}
+
+    def create_inverse_map(symb_to_real_map):
+        rev_items = lambda item: (item[1], item[0])
+        return dict(map(rev_items, symb_to_real_map.items()))
+
+    if start is not None:
+        if not isinstance(start, Symbol):
+            msg = 'Expected Symbol for starting index, got %r.' % start
+            raise TypeError(msg)
+        cur_ndx = start
+
+    if gen is not None:
+        if not isinstance(gen, numbered_symbols().__class__):
+            msg = 'Expected a generator, got %r.' % gen
+            raise TypeError(msg)
+        index_gen = gen
+
+    if qubit_map is not None:
+        if not isinstance(qubit_map, dict):
+            msg = ('Expected dict for existing map, got ' +
+                   '%r.' % qubit_map)
+            raise TypeError(msg)
+        ndx_map = qubit_map
+
+    ndx_map = _sympify_qubit_map(ndx_map)
+    # keys are real indices; keys are symbolic indices
+    inv_map = create_inverse_map(ndx_map)
+
+    sym_seq = ()
+    for item in seq:
+        # Nested items, so recurse
+        if isinstance(item, Gate):
+            result = convert_to_symbolic_indices(item.args,
+                                                 qubit_map=ndx_map,
+                                                 start=cur_ndx,
+                                                 gen=index_gen)
+            sym_item, new_map, cur_ndx, index_gen = result
+            ndx_map.update(new_map)
+            inv_map = create_inverse_map(ndx_map)
+
+        elif isinstance(item, (tuple, Tuple)):
+            result = convert_to_symbolic_indices(item,
+                                                 qubit_map=ndx_map,
+                                                 start=cur_ndx,
+                                                 gen=index_gen)
+            sym_item, new_map, cur_ndx, index_gen = result
+            ndx_map.update(new_map)
+            inv_map = create_inverse_map(ndx_map)
+
+        elif item in inv_map:
+            sym_item = inv_map[item]
+
+        else:
+            cur_ndx = next(gen)
+            ndx_map[cur_ndx] = item
+            inv_map[item] = cur_ndx
+            sym_item = cur_ndx
+
+        if isinstance(item, Gate):
+            sym_item = item.__class__(*sym_item)
+
+        sym_seq = sym_seq + (sym_item,)
+
+    return sym_seq, ndx_map, cur_ndx, index_gen
+
+
+def convert_to_real_indices(seq, qubit_map):
+    """Returns the circuit with real indices.
+
+    Parameters
+    ==========
+
+    seq : tuple, Gate/Integer/tuple or Mul
+        A tuple of Gate, Integer, or tuple objects or a Mul
+    qubit_map : dict
+        A dictionary mapping symbolic indices to real indices.
+
+    Examples
+    ========
+
+    Change the symbolic indices to real integers:
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.quantum.circuitutils import convert_to_real_indices
+    >>> from sympy.physics.quantum.gate import X, Y, H
+    >>> i0, i1 = symbols('i:2')
+    >>> index_map = {i0 : 0, i1 : 1}
+    >>> convert_to_real_indices(X(i0)*Y(i1)*H(i0)*X(i1), index_map)
+    (X(0), Y(1), H(0), X(1))
+    """
+
+    if isinstance(seq, Mul):
+        seq = seq.args
+
+    if not isinstance(qubit_map, dict):
+        msg = 'Expected dict for qubit_map, got %r.' % qubit_map
+        raise TypeError(msg)
+
+    qubit_map = _sympify_qubit_map(qubit_map)
+    real_seq = ()
+    for item in seq:
+        # Nested items, so recurse
+        if isinstance(item, Gate):
+            real_item = convert_to_real_indices(item.args, qubit_map)
+
+        elif isinstance(item, (tuple, Tuple)):
+            real_item = convert_to_real_indices(item, qubit_map)
+
+        else:
+            real_item = qubit_map[item]
+
+        if isinstance(item, Gate):
+            real_item = item.__class__(*real_item)
+
+        real_seq = real_seq + (real_item,)
+
+    return real_seq
+
+
+def random_reduce(circuit, gate_ids, seed=None):
+    """Shorten the length of a quantum circuit.
+
+    Explanation
+    ===========
+
+    random_reduce looks for circuit identities in circuit, randomly chooses
+    one to remove, and returns a shorter yet equivalent circuit.  If no
+    identities are found, the same circuit is returned.
+
+    Parameters
+    ==========
+
+    circuit : Gate tuple of Mul
+        A tuple of Gates representing a quantum circuit
+    gate_ids : list, GateIdentity
+        List of gate identities to find in circuit
+    seed : int or list
+        seed used for _randrange; to override the random selection, provide a
+        list of integers: the elements of gate_ids will be tested in the order
+        given by the list
+
+    """
+    from sympy.core.random import _randrange
+
+    if not gate_ids:
+        return circuit
+
+    if isinstance(circuit, Mul):
+        circuit = circuit.args
+
+    ids = flatten_ids(gate_ids)
+
+    # Create the random integer generator with the seed
+    randrange = _randrange(seed)
+
+    # Look for an identity in the circuit
+    while ids:
+        i = randrange(len(ids))
+        id = ids.pop(i)
+        if find_subcircuit(circuit, id) != -1:
+            break
+    else:
+        # no identity was found
+        return circuit
+
+    # return circuit with the identity removed
+    return replace_subcircuit(circuit, id)
+
+
+def random_insert(circuit, choices, seed=None):
+    """Insert a circuit into another quantum circuit.
+
+    Explanation
+    ===========
+
+    random_insert randomly chooses a location in the circuit to insert
+    a randomly selected circuit from amongst the given choices.
+
+    Parameters
+    ==========
+
+    circuit : Gate tuple or Mul
+        A tuple or Mul of Gates representing a quantum circuit
+    choices : list
+        Set of circuit choices
+    seed : int or list
+        seed used for _randrange; to override the random selections, give
+        a list two integers, [i, j] where i is the circuit location where
+        choice[j] will be inserted.
+
+    Notes
+    =====
+
+    Indices for insertion should be [0, n] if n is the length of the
+    circuit.
+    """
+    from sympy.core.random import _randrange
+
+    if not choices:
+        return circuit
+
+    if isinstance(circuit, Mul):
+        circuit = circuit.args
+
+    # get the location in the circuit and the element to insert from choices
+    randrange = _randrange(seed)
+    loc = randrange(len(circuit) + 1)
+    choice = choices[randrange(len(choices))]
+
+    circuit = list(circuit)
+    circuit[loc: loc] = choice
+    return tuple(circuit)
+
+# Flatten the GateIdentity objects (with gate rules) into one single list
+
+
+def flatten_ids(ids):
+    collapse = lambda acc, an_id: acc + sorted(an_id.equivalent_ids,
+                                        key=default_sort_key)
+    ids = reduce(collapse, ids, [])
+    ids.sort(key=default_sort_key)
+    return ids

venv/lib/python3.10/site-packages/sympy/physics/quantum/commutator.py

@@ -0,0 +1,239 @@
+"""The commutator: [A,B] = A*B - B*A."""
+
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.printing.pretty.stringpict import prettyForm
+
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.operator import Operator
+
+
+__all__ = [
+    'Commutator'
+]
+
+#-----------------------------------------------------------------------------
+# Commutator
+#-----------------------------------------------------------------------------
+
+
+class Commutator(Expr):
+    """The standard commutator, in an unevaluated state.
+
+    Explanation
+    ===========
+
+    Evaluating a commutator is defined [1]_ as: ``[A, B] = A*B - B*A``. This
+    class returns the commutator in an unevaluated form. To evaluate the
+    commutator, use the ``.doit()`` method.
+
+    Canonical ordering of a commutator is ``[A, B]`` for ``A < B``. The
+    arguments of the commutator are put into canonical order using ``__cmp__``.
+    If ``B < A``, then ``[B, A]`` is returned as ``-[A, B]``.
+
+    Parameters
+    ==========
+
+    A : Expr
+        The first argument of the commutator [A,B].
+    B : Expr
+        The second argument of the commutator [A,B].
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import Commutator, Dagger, Operator
+    >>> from sympy.abc import x, y
+    >>> A = Operator('A')
+    >>> B = Operator('B')
+    >>> C = Operator('C')
+
+    Create a commutator and use ``.doit()`` to evaluate it:
+
+    >>> comm = Commutator(A, B)
+    >>> comm
+    [A,B]
+    >>> comm.doit()
+    A*B - B*A
+
+    The commutator orders it arguments in canonical order:
+
+    >>> comm = Commutator(B, A); comm
+    -[A,B]
+
+    Commutative constants are factored out:
+
+    >>> Commutator(3*x*A, x*y*B)
+    3*x**2*y*[A,B]
+
+    Using ``.expand(commutator=True)``, the standard commutator expansion rules
+    can be applied:
+
+    >>> Commutator(A+B, C).expand(commutator=True)
+    [A,C] + [B,C]
+    >>> Commutator(A, B+C).expand(commutator=True)
+    [A,B] + [A,C]
+    >>> Commutator(A*B, C).expand(commutator=True)
+    [A,C]*B + A*[B,C]
+    >>> Commutator(A, B*C).expand(commutator=True)
+    [A,B]*C + B*[A,C]
+
+    Adjoint operations applied to the commutator are properly applied to the
+    arguments:
+
+    >>> Dagger(Commutator(A, B))
+    -[Dagger(A),Dagger(B)]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Commutator
+    """
+    is_commutative = False
+
+    def __new__(cls, A, B):
+        r = cls.eval(A, B)
+        if r is not None:
+            return r
+        obj = Expr.__new__(cls, A, B)
+        return obj
+
+    @classmethod
+    def eval(cls, a, b):
+        if not (a and b):
+            return S.Zero
+        if a == b:
+            return S.Zero
+        if a.is_commutative or b.is_commutative:
+            return S.Zero
+
+        # [xA,yB]  ->  xy*[A,B]
+        ca, nca = a.args_cnc()
+        cb, ncb = b.args_cnc()
+        c_part = ca + cb
+        if c_part:
+            return Mul(Mul(*c_part), cls(Mul._from_args(nca), Mul._from_args(ncb)))
+
+        # Canonical ordering of arguments
+        # The Commutator [A, B] is in canonical form if A < B.
+        if a.compare(b) == 1:
+            return S.NegativeOne*cls(b, a)
+
+    def _expand_pow(self, A, B, sign):
+        exp = A.exp
+        if not exp.is_integer or not exp.is_constant() or abs(exp) <= 1:
+            # nothing to do
+            return self
+        base = A.base
+        if exp.is_negative:
+            base = A.base**-1
+            exp = -exp
+        comm = Commutator(base, B).expand(commutator=True)
+
+        result = base**(exp - 1) * comm
+        for i in range(1, exp):
+            result += base**(exp - 1 - i) * comm * base**i
+        return sign*result.expand()
+
+    def _eval_expand_commutator(self, **hints):
+        A = self.args[0]
+        B = self.args[1]
+
+        if isinstance(A, Add):
+            # [A + B, C]  ->  [A, C] + [B, C]
+            sargs = []
+            for term in A.args:
+                comm = Commutator(term, B)
+                if isinstance(comm, Commutator):
+                    comm = comm._eval_expand_commutator()
+                sargs.append(comm)
+            return Add(*sargs)
+        elif isinstance(B, Add):
+            # [A, B + C]  ->  [A, B] + [A, C]
+            sargs = []
+            for term in B.args:
+                comm = Commutator(A, term)
+                if isinstance(comm, Commutator):
+                    comm = comm._eval_expand_commutator()
+                sargs.append(comm)
+            return Add(*sargs)
+        elif isinstance(A, Mul):
+            # [A*B, C] -> A*[B, C] + [A, C]*B
+            a = A.args[0]
+            b = Mul(*A.args[1:])
+            c = B
+            comm1 = Commutator(b, c)
+            comm2 = Commutator(a, c)
+            if isinstance(comm1, Commutator):
+                comm1 = comm1._eval_expand_commutator()
+            if isinstance(comm2, Commutator):
+                comm2 = comm2._eval_expand_commutator()
+            first = Mul(a, comm1)
+            second = Mul(comm2, b)
+            return Add(first, second)
+        elif isinstance(B, Mul):
+            # [A, B*C] -> [A, B]*C + B*[A, C]
+            a = A
+            b = B.args[0]
+            c = Mul(*B.args[1:])
+            comm1 = Commutator(a, b)
+            comm2 = Commutator(a, c)
+            if isinstance(comm1, Commutator):
+                comm1 = comm1._eval_expand_commutator()
+            if isinstance(comm2, Commutator):
+                comm2 = comm2._eval_expand_commutator()
+            first = Mul(comm1, c)
+            second = Mul(b, comm2)
+            return Add(first, second)
+        elif isinstance(A, Pow):
+            # [A**n, C] -> A**(n - 1)*[A, C] + A**(n - 2)*[A, C]*A + ... + [A, C]*A**(n-1)
+            return self._expand_pow(A, B, 1)
+        elif isinstance(B, Pow):
+            # [A, C**n] -> C**(n - 1)*[C, A] + C**(n - 2)*[C, A]*C + ... + [C, A]*C**(n-1)
+            return self._expand_pow(B, A, -1)
+
+        # No changes, so return self
+        return self
+
+    def doit(self, **hints):
+        """ Evaluate commutator """
+        A = self.args[0]
+        B = self.args[1]
+        if isinstance(A, Operator) and isinstance(B, Operator):
+            try:
+                comm = A._eval_commutator(B, **hints)
+            except NotImplementedError:
+                try:
+                    comm = -1*B._eval_commutator(A, **hints)
+                except NotImplementedError:
+                    comm = None
+            if comm is not None:
+                return comm.doit(**hints)
+        return (A*B - B*A).doit(**hints)
+
+    def _eval_adjoint(self):
+        return Commutator(Dagger(self.args[1]), Dagger(self.args[0]))
+
+    def _sympyrepr(self, printer, *args):
+        return "%s(%s,%s)" % (
+            self.__class__.__name__, printer._print(
+                self.args[0]), printer._print(self.args[1])
+        )
+
+    def _sympystr(self, printer, *args):
+        return "[%s,%s]" % (
+            printer._print(self.args[0]), printer._print(self.args[1]))
+
+    def _pretty(self, printer, *args):
+        pform = printer._print(self.args[0], *args)
+        pform = prettyForm(*pform.right(prettyForm(',')))
+        pform = prettyForm(*pform.right(printer._print(self.args[1], *args)))
+        pform = prettyForm(*pform.parens(left='[', right=']'))
+        return pform
+
+    def _latex(self, printer, *args):
+        return "\\left[%s,%s\\right]" % tuple([
+            printer._print(arg, *args) for arg in self.args])

venv/lib/python3.10/site-packages/sympy/physics/quantum/constants.py

@@ -0,0 +1,59 @@
+"""Constants (like hbar) related to quantum mechanics."""
+
+from sympy.core.numbers import NumberSymbol
+from sympy.core.singleton import Singleton
+from sympy.printing.pretty.stringpict import prettyForm
+import mpmath.libmp as mlib
+
+#-----------------------------------------------------------------------------
+# Constants
+#-----------------------------------------------------------------------------
+
+__all__ = [
+    'hbar',
+    'HBar',
+]
+
+
+class HBar(NumberSymbol, metaclass=Singleton):
+    """Reduced Plank's constant in numerical and symbolic form [1]_.
+
+    Examples
+    ========
+
+        >>> from sympy.physics.quantum.constants import hbar
+        >>> hbar.evalf()
+        1.05457162000000e-34
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Planck_constant
+    """
+
+    is_real = True
+    is_positive = True
+    is_negative = False
+    is_irrational = True
+
+    __slots__ = ()
+
+    def _as_mpf_val(self, prec):
+        return mlib.from_float(1.05457162e-34, prec)
+
+    def _sympyrepr(self, printer, *args):
+        return 'HBar()'
+
+    def _sympystr(self, printer, *args):
+        return 'hbar'
+
+    def _pretty(self, printer, *args):
+        if printer._use_unicode:
+            return prettyForm('\N{PLANCK CONSTANT OVER TWO PI}')
+        return prettyForm('hbar')
+
+    def _latex(self, printer, *args):
+        return r'\hbar'
+
+# Create an instance for everyone to use.
+hbar = HBar()

venv/lib/python3.10/site-packages/sympy/physics/quantum/dagger.py

@@ -0,0 +1,97 @@
+"""Hermitian conjugation."""
+
+from sympy.core import Expr, Mul
+from sympy.functions.elementary.complexes import adjoint
+
+__all__ = [
+    'Dagger'
+]
+
+
+class Dagger(adjoint):
+    """General Hermitian conjugate operation.
+
+    Explanation
+    ===========
+
+    Take the Hermetian conjugate of an argument [1]_. For matrices this
+    operation is equivalent to transpose and complex conjugate [2]_.
+
+    Parameters
+    ==========
+
+    arg : Expr
+        The SymPy expression that we want to take the dagger of.
+
+    Examples
+    ========
+
+    Daggering various quantum objects:
+
+        >>> from sympy.physics.quantum.dagger import Dagger
+        >>> from sympy.physics.quantum.state import Ket, Bra
+        >>> from sympy.physics.quantum.operator import Operator
+        >>> Dagger(Ket('psi'))
+        <psi|
+        >>> Dagger(Bra('phi'))
+        |phi>
+        >>> Dagger(Operator('A'))
+        Dagger(A)
+
+    Inner and outer products::
+
+        >>> from sympy.physics.quantum import InnerProduct, OuterProduct
+        >>> Dagger(InnerProduct(Bra('a'), Ket('b')))
+        <b|a>
+        >>> Dagger(OuterProduct(Ket('a'), Bra('b')))
+        |b><a|
+
+    Powers, sums and products::
+
+        >>> A = Operator('A')
+        >>> B = Operator('B')
+        >>> Dagger(A*B)
+        Dagger(B)*Dagger(A)
+        >>> Dagger(A+B)
+        Dagger(A) + Dagger(B)
+        >>> Dagger(A**2)
+        Dagger(A)**2
+
+    Dagger also seamlessly handles complex numbers and matrices::
+
+        >>> from sympy import Matrix, I
+        >>> m = Matrix([[1,I],[2,I]])
+        >>> m
+        Matrix([
+        [1, I],
+        [2, I]])
+        >>> Dagger(m)
+        Matrix([
+        [ 1,  2],
+        [-I, -I]])
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hermitian_adjoint
+    .. [2] https://en.wikipedia.org/wiki/Hermitian_transpose
+    """
+
+    def __new__(cls, arg):
+        if hasattr(arg, 'adjoint'):
+            obj = arg.adjoint()
+        elif hasattr(arg, 'conjugate') and hasattr(arg, 'transpose'):
+            obj = arg.conjugate().transpose()
+        if obj is not None:
+            return obj
+        return Expr.__new__(cls, arg)
+
+    def __mul__(self, other):
+        from sympy.physics.quantum import IdentityOperator
+        if isinstance(other, IdentityOperator):
+            return self
+
+        return Mul(self, other)
+
+adjoint.__name__ = "Dagger"
+adjoint._sympyrepr = lambda a, b: "Dagger(%s)" % b._print(a.args[0])

venv/lib/python3.10/site-packages/sympy/physics/quantum/density.py

@@ -0,0 +1,319 @@
+from itertools import product
+
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.function import expand
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import log
+from sympy.matrices.dense import MutableDenseMatrix as Matrix
+from sympy.printing.pretty.stringpict import prettyForm
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.operator import HermitianOperator
+from sympy.physics.quantum.represent import represent
+from sympy.physics.quantum.matrixutils import numpy_ndarray, scipy_sparse_matrix, to_numpy
+from sympy.physics.quantum.tensorproduct import TensorProduct, tensor_product_simp
+from sympy.physics.quantum.trace import Tr
+
+
+class Density(HermitianOperator):
+    """Density operator for representing mixed states.
+
+    TODO: Density operator support for Qubits
+
+    Parameters
+    ==========
+
+    values : tuples/lists
+    Each tuple/list should be of form (state, prob) or [state,prob]
+
+    Examples
+    ========
+
+    Create a density operator with 2 states represented by Kets.
+
+    >>> from sympy.physics.quantum.state import Ket
+    >>> from sympy.physics.quantum.density import Density
+    >>> d = Density([Ket(0), 0.5], [Ket(1),0.5])
+    >>> d
+    Density((|0>, 0.5),(|1>, 0.5))
+
+    """
+    @classmethod
+    def _eval_args(cls, args):
+        # call this to qsympify the args
+        args = super()._eval_args(args)
+
+        for arg in args:
+            # Check if arg is a tuple
+            if not (isinstance(arg, Tuple) and len(arg) == 2):
+                raise ValueError("Each argument should be of form [state,prob]"
+                                 " or ( state, prob )")
+
+        return args
+
+    def states(self):
+        """Return list of all states.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.state import Ket
+        >>> from sympy.physics.quantum.density import Density
+        >>> d = Density([Ket(0), 0.5], [Ket(1),0.5])
+        >>> d.states()
+        (|0>, |1>)
+
+        """
+        return Tuple(*[arg[0] for arg in self.args])
+
+    def probs(self):
+        """Return list of all probabilities.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.state import Ket
+        >>> from sympy.physics.quantum.density import Density
+        >>> d = Density([Ket(0), 0.5], [Ket(1),0.5])
+        >>> d.probs()
+        (0.5, 0.5)
+
+        """
+        return Tuple(*[arg[1] for arg in self.args])
+
+    def get_state(self, index):
+        """Return specific state by index.
+
+        Parameters
+        ==========
+
+        index : index of state to be returned
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.state import Ket
+        >>> from sympy.physics.quantum.density import Density
+        >>> d = Density([Ket(0), 0.5], [Ket(1),0.5])
+        >>> d.states()[1]
+        |1>
+
+        """
+        state = self.args[index][0]
+        return state
+
+    def get_prob(self, index):
+        """Return probability of specific state by index.
+
+        Parameters
+        ===========
+
+        index : index of states whose probability is returned.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.state import Ket
+        >>> from sympy.physics.quantum.density import Density
+        >>> d = Density([Ket(0), 0.5], [Ket(1),0.5])
+        >>> d.probs()[1]
+        0.500000000000000
+
+        """
+        prob = self.args[index][1]
+        return prob
+
+    def apply_op(self, op):
+        """op will operate on each individual state.
+
+        Parameters
+        ==========
+
+        op : Operator
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.state import Ket
+        >>> from sympy.physics.quantum.density import Density
+        >>> from sympy.physics.quantum.operator import Operator
+        >>> A = Operator('A')
+        >>> d = Density([Ket(0), 0.5], [Ket(1),0.5])
+        >>> d.apply_op(A)
+        Density((A*|0>, 0.5),(A*|1>, 0.5))
+
+        """
+        new_args = [(op*state, prob) for (state, prob) in self.args]
+        return Density(*new_args)
+
+    def doit(self, **hints):
+        """Expand the density operator into an outer product format.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.state import Ket
+        >>> from sympy.physics.quantum.density import Density
+        >>> from sympy.physics.quantum.operator import Operator
+        >>> A = Operator('A')
+        >>> d = Density([Ket(0), 0.5], [Ket(1),0.5])
+        >>> d.doit()
+        0.5*|0><0| + 0.5*|1><1|
+
+        """
+
+        terms = []
+        for (state, prob) in self.args:
+            state = state.expand()  # needed to break up (a+b)*c
+            if (isinstance(state, Add)):
+                for arg in product(state.args, repeat=2):
+                    terms.append(prob*self._generate_outer_prod(arg[0],
+                                                                arg[1]))
+            else:
+                terms.append(prob*self._generate_outer_prod(state, state))
+
+        return Add(*terms)
+
+    def _generate_outer_prod(self, arg1, arg2):
+        c_part1, nc_part1 = arg1.args_cnc()
+        c_part2, nc_part2 = arg2.args_cnc()
+
+        if (len(nc_part1) == 0 or len(nc_part2) == 0):
+            raise ValueError('Atleast one-pair of'
+                             ' Non-commutative instance required'
+                             ' for outer product.')
+
+        # Muls of Tensor Products should be expanded
+        # before this function is called
+        if (isinstance(nc_part1[0], TensorProduct) and len(nc_part1) == 1
+                and len(nc_part2) == 1):
+            op = tensor_product_simp(nc_part1[0]*Dagger(nc_part2[0]))
+        else:
+            op = Mul(*nc_part1)*Dagger(Mul(*nc_part2))
+
+        return Mul(*c_part1)*Mul(*c_part2) * op
+
+    def _represent(self, **options):
+        return represent(self.doit(), **options)
+
+    def _print_operator_name_latex(self, printer, *args):
+        return r'\rho'
+
+    def _print_operator_name_pretty(self, printer, *args):
+        return prettyForm('\N{GREEK SMALL LETTER RHO}')
+
+    def _eval_trace(self, **kwargs):
+        indices = kwargs.get('indices', [])
+        return Tr(self.doit(), indices).doit()
+
+    def entropy(self):
+        """ Compute the entropy of a density matrix.
+
+        Refer to density.entropy() method  for examples.
+        """
+        return entropy(self)
+
+
+def entropy(density):
+    """Compute the entropy of a matrix/density object.
+
+    This computes -Tr(density*ln(density)) using the eigenvalue decomposition
+    of density, which is given as either a Density instance or a matrix
+    (numpy.ndarray, sympy.Matrix or scipy.sparse).
+
+    Parameters
+    ==========
+
+    density : density matrix of type Density, SymPy matrix,
+    scipy.sparse or numpy.ndarray
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.density import Density, entropy
+    >>> from sympy.physics.quantum.spin import JzKet
+    >>> from sympy import S
+    >>> up = JzKet(S(1)/2,S(1)/2)
+    >>> down = JzKet(S(1)/2,-S(1)/2)
+    >>> d = Density((up,S(1)/2),(down,S(1)/2))
+    >>> entropy(d)
+    log(2)/2
+
+    """
+    if isinstance(density, Density):
+        density = represent(density)  # represent in Matrix
+
+    if isinstance(density, scipy_sparse_matrix):
+        density = to_numpy(density)
+
+    if isinstance(density, Matrix):
+        eigvals = density.eigenvals().keys()
+        return expand(-sum(e*log(e) for e in eigvals))
+    elif isinstance(density, numpy_ndarray):
+        import numpy as np
+        eigvals = np.linalg.eigvals(density)
+        return -np.sum(eigvals*np.log(eigvals))
+    else:
+        raise ValueError(
+            "numpy.ndarray, scipy.sparse or SymPy matrix expected")
+
+
+def fidelity(state1, state2):
+    """ Computes the fidelity [1]_ between two quantum states
+
+    The arguments provided to this function should be a square matrix or a
+    Density object. If it is a square matrix, it is assumed to be diagonalizable.
+
+    Parameters
+    ==========
+
+    state1, state2 : a density matrix or Matrix
+
+
+    Examples
+    ========
+
+    >>> from sympy import S, sqrt
+    >>> from sympy.physics.quantum.dagger import Dagger
+    >>> from sympy.physics.quantum.spin import JzKet
+    >>> from sympy.physics.quantum.density import fidelity
+    >>> from sympy.physics.quantum.represent import represent
+    >>>
+    >>> up = JzKet(S(1)/2,S(1)/2)
+    >>> down = JzKet(S(1)/2,-S(1)/2)
+    >>> amp = 1/sqrt(2)
+    >>> updown = (amp*up) + (amp*down)
+    >>>
+    >>> # represent turns Kets into matrices
+    >>> up_dm = represent(up*Dagger(up))
+    >>> down_dm = represent(down*Dagger(down))
+    >>> updown_dm = represent(updown*Dagger(updown))
+    >>>
+    >>> fidelity(up_dm, up_dm)
+    1
+    >>> fidelity(up_dm, down_dm) #orthogonal states
+    0
+    >>> fidelity(up_dm, updown_dm).evalf().round(3)
+    0.707
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fidelity_of_quantum_states
+
+    """
+    state1 = represent(state1) if isinstance(state1, Density) else state1
+    state2 = represent(state2) if isinstance(state2, Density) else state2
+
+    if not isinstance(state1, Matrix) or not isinstance(state2, Matrix):
+        raise ValueError("state1 and state2 must be of type Density or Matrix "
+                         "received type=%s for state1 and type=%s for state2" %
+                         (type(state1), type(state2)))
+
+    if state1.shape != state2.shape and state1.is_square:
+        raise ValueError("The dimensions of both args should be equal and the "
+                         "matrix obtained should be a square matrix")
+
+    sqrt_state1 = state1**S.Half
+    return Tr((sqrt_state1*state2*sqrt_state1)**S.Half).doit()

venv/lib/python3.10/site-packages/sympy/physics/quantum/gate.py

@@ -0,0 +1,1305 @@
+"""An implementation of gates that act on qubits.
+
+Gates are unitary operators that act on the space of qubits.
+
+Medium Term Todo:
+
+* Optimize Gate._apply_operators_Qubit to remove the creation of many
+  intermediate Qubit objects.
+* Add commutation relationships to all operators and use this in gate_sort.
+* Fix gate_sort and gate_simp.
+* Get multi-target UGates plotting properly.
+* Get UGate to work with either sympy/numpy matrices and output either
+  format. This should also use the matrix slots.
+"""
+
+from itertools import chain
+import random
+
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Integer)
+from sympy.core.power import Pow
+from sympy.core.numbers import Number
+from sympy.core.singleton import S as _S
+from sympy.core.sorting import default_sort_key
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.printing.pretty.stringpict import prettyForm, stringPict
+
+from sympy.physics.quantum.anticommutator import AntiCommutator
+from sympy.physics.quantum.commutator import Commutator
+from sympy.physics.quantum.qexpr import QuantumError
+from sympy.physics.quantum.hilbert import ComplexSpace
+from sympy.physics.quantum.operator import (UnitaryOperator, Operator,
+                                            HermitianOperator)
+from sympy.physics.quantum.matrixutils import matrix_tensor_product, matrix_eye
+from sympy.physics.quantum.matrixcache import matrix_cache
+
+from sympy.matrices.matrices import MatrixBase
+
+from sympy.utilities.iterables import is_sequence
+
+__all__ = [
+    'Gate',
+    'CGate',
+    'UGate',
+    'OneQubitGate',
+    'TwoQubitGate',
+    'IdentityGate',
+    'HadamardGate',
+    'XGate',
+    'YGate',
+    'ZGate',
+    'TGate',
+    'PhaseGate',
+    'SwapGate',
+    'CNotGate',
+    # Aliased gate names
+    'CNOT',
+    'SWAP',
+    'H',
+    'X',
+    'Y',
+    'Z',
+    'T',
+    'S',
+    'Phase',
+    'normalized',
+    'gate_sort',
+    'gate_simp',
+    'random_circuit',
+    'CPHASE',
+    'CGateS',
+]
+
+#-----------------------------------------------------------------------------
+# Gate Super-Classes
+#-----------------------------------------------------------------------------
+
+_normalized = True
+
+
+def _max(*args, **kwargs):
+    if "key" not in kwargs:
+        kwargs["key"] = default_sort_key
+    return max(*args, **kwargs)
+
+
+def _min(*args, **kwargs):
+    if "key" not in kwargs:
+        kwargs["key"] = default_sort_key
+    return min(*args, **kwargs)
+
+
+def normalized(normalize):
+    r"""Set flag controlling normalization of Hadamard gates by `1/\sqrt{2}`.
+
+    This is a global setting that can be used to simplify the look of various
+    expressions, by leaving off the leading `1/\sqrt{2}` of the Hadamard gate.
+
+    Parameters
+    ----------
+    normalize : bool
+        Should the Hadamard gate include the `1/\sqrt{2}` normalization factor?
+        When True, the Hadamard gate will have the `1/\sqrt{2}`. When False, the
+        Hadamard gate will not have this factor.
+    """
+    global _normalized
+    _normalized = normalize
+
+
+def _validate_targets_controls(tandc):
+    tandc = list(tandc)
+    # Check for integers
+    for bit in tandc:
+        if not bit.is_Integer and not bit.is_Symbol:
+            raise TypeError('Integer expected, got: %r' % tandc[bit])
+    # Detect duplicates
+    if len(set(tandc)) != len(tandc):
+        raise QuantumError(
+            'Target/control qubits in a gate cannot be duplicated'
+        )
+
+
+class Gate(UnitaryOperator):
+    """Non-controlled unitary gate operator that acts on qubits.
+
+    This is a general abstract gate that needs to be subclassed to do anything
+    useful.
+
+    Parameters
+    ----------
+    label : tuple, int
+        A list of the target qubits (as ints) that the gate will apply to.
+
+    Examples
+    ========
+
+
+    """
+
+    _label_separator = ','
+
+    gate_name = 'G'
+    gate_name_latex = 'G'
+
+    #-------------------------------------------------------------------------
+    # Initialization/creation
+    #-------------------------------------------------------------------------
+
+    @classmethod
+    def _eval_args(cls, args):
+        args = Tuple(*UnitaryOperator._eval_args(args))
+        _validate_targets_controls(args)
+        return args
+
+    @classmethod
+    def _eval_hilbert_space(cls, args):
+        """This returns the smallest possible Hilbert space."""
+        return ComplexSpace(2)**(_max(args) + 1)
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def nqubits(self):
+        """The total number of qubits this gate acts on.
+
+        For controlled gate subclasses this includes both target and control
+        qubits, so that, for examples the CNOT gate acts on 2 qubits.
+        """
+        return len(self.targets)
+
+    @property
+    def min_qubits(self):
+        """The minimum number of qubits this gate needs to act on."""
+        return _max(self.targets) + 1
+
+    @property
+    def targets(self):
+        """A tuple of target qubits."""
+        return self.label
+
+    @property
+    def gate_name_plot(self):
+        return r'$%s$' % self.gate_name_latex
+
+    #-------------------------------------------------------------------------
+    # Gate methods
+    #-------------------------------------------------------------------------
+
+    def get_target_matrix(self, format='sympy'):
+        """The matrix representation of the target part of the gate.
+
+        Parameters
+        ----------
+        format : str
+            The format string ('sympy','numpy', etc.)
+        """
+        raise NotImplementedError(
+            'get_target_matrix is not implemented in Gate.')
+
+    #-------------------------------------------------------------------------
+    # Apply
+    #-------------------------------------------------------------------------
+
+    def _apply_operator_IntQubit(self, qubits, **options):
+        """Redirect an apply from IntQubit to Qubit"""
+        return self._apply_operator_Qubit(qubits, **options)
+
+    def _apply_operator_Qubit(self, qubits, **options):
+        """Apply this gate to a Qubit."""
+
+        # Check number of qubits this gate acts on.
+        if qubits.nqubits < self.min_qubits:
+            raise QuantumError(
+                'Gate needs a minimum of %r qubits to act on, got: %r' %
+                (self.min_qubits, qubits.nqubits)
+            )
+
+        # If the controls are not met, just return
+        if isinstance(self, CGate):
+            if not self.eval_controls(qubits):
+                return qubits
+
+        targets = self.targets
+        target_matrix = self.get_target_matrix(format='sympy')
+
+        # Find which column of the target matrix this applies to.
+        column_index = 0
+        n = 1
+        for target in targets:
+            column_index += n*qubits[target]
+            n = n << 1
+        column = target_matrix[:, int(column_index)]
+
+        # Now apply each column element to the qubit.
+        result = 0
+        for index in range(column.rows):
+            # TODO: This can be optimized to reduce the number of Qubit
+            # creations. We should simply manipulate the raw list of qubit
+            # values and then build the new Qubit object once.
+            # Make a copy of the incoming qubits.
+            new_qubit = qubits.__class__(*qubits.args)
+            # Flip the bits that need to be flipped.
+            for bit, target in enumerate(targets):
+                if new_qubit[target] != (index >> bit) & 1:
+                    new_qubit = new_qubit.flip(target)
+            # The value in that row and column times the flipped-bit qubit
+            # is the result for that part.
+            result += column[index]*new_qubit
+        return result
+
+    #-------------------------------------------------------------------------
+    # Represent
+    #-------------------------------------------------------------------------
+
+    def _represent_default_basis(self, **options):
+        return self._represent_ZGate(None, **options)
+
+    def _represent_ZGate(self, basis, **options):
+        format = options.get('format', 'sympy')
+        nqubits = options.get('nqubits', 0)
+        if nqubits == 0:
+            raise QuantumError(
+                'The number of qubits must be given as nqubits.')
+
+        # Make sure we have enough qubits for the gate.
+        if nqubits < self.min_qubits:
+            raise QuantumError(
+                'The number of qubits %r is too small for the gate.' % nqubits
+            )
+
+        target_matrix = self.get_target_matrix(format)
+        targets = self.targets
+        if isinstance(self, CGate):
+            controls = self.controls
+        else:
+            controls = []
+        m = represent_zbasis(
+            controls, targets, target_matrix, nqubits, format
+        )
+        return m
+
+    #-------------------------------------------------------------------------
+    # Print methods
+    #-------------------------------------------------------------------------
+
+    def _sympystr(self, printer, *args):
+        label = self._print_label(printer, *args)
+        return '%s(%s)' % (self.gate_name, label)
+
+    def _pretty(self, printer, *args):
+        a = stringPict(self.gate_name)
+        b = self._print_label_pretty(printer, *args)
+        return self._print_subscript_pretty(a, b)
+
+    def _latex(self, printer, *args):
+        label = self._print_label(printer, *args)
+        return '%s_{%s}' % (self.gate_name_latex, label)
+
+    def plot_gate(self, axes, gate_idx, gate_grid, wire_grid):
+        raise NotImplementedError('plot_gate is not implemented.')
+
+
+class CGate(Gate):
+    """A general unitary gate with control qubits.
+
+    A general control gate applies a target gate to a set of targets if all
+    of the control qubits have a particular values (set by
+    ``CGate.control_value``).
+
+    Parameters
+    ----------
+    label : tuple
+        The label in this case has the form (controls, gate), where controls
+        is a tuple/list of control qubits (as ints) and gate is a ``Gate``
+        instance that is the target operator.
+
+    Examples
+    ========
+
+    """
+
+    gate_name = 'C'
+    gate_name_latex = 'C'
+
+    # The values this class controls for.
+    control_value = _S.One
+
+    simplify_cgate = False
+
+    #-------------------------------------------------------------------------
+    # Initialization
+    #-------------------------------------------------------------------------
+
+    @classmethod
+    def _eval_args(cls, args):
+        # _eval_args has the right logic for the controls argument.
+        controls = args[0]
+        gate = args[1]
+        if not is_sequence(controls):
+            controls = (controls,)
+        controls = UnitaryOperator._eval_args(controls)
+        _validate_targets_controls(chain(controls, gate.targets))
+        return (Tuple(*controls), gate)
+
+    @classmethod
+    def _eval_hilbert_space(cls, args):
+        """This returns the smallest possible Hilbert space."""
+        return ComplexSpace(2)**_max(_max(args[0]) + 1, args[1].min_qubits)
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def nqubits(self):
+        """The total number of qubits this gate acts on.
+
+        For controlled gate subclasses this includes both target and control
+        qubits, so that, for examples the CNOT gate acts on 2 qubits.
+        """
+        return len(self.targets) + len(self.controls)
+
+    @property
+    def min_qubits(self):
+        """The minimum number of qubits this gate needs to act on."""
+        return _max(_max(self.controls), _max(self.targets)) + 1
+
+    @property
+    def targets(self):
+        """A tuple of target qubits."""
+        return self.gate.targets
+
+    @property
+    def controls(self):
+        """A tuple of control qubits."""
+        return tuple(self.label[0])
+
+    @property
+    def gate(self):
+        """The non-controlled gate that will be applied to the targets."""
+        return self.label[1]
+
+    #-------------------------------------------------------------------------
+    # Gate methods
+    #-------------------------------------------------------------------------
+
+    def get_target_matrix(self, format='sympy'):
+        return self.gate.get_target_matrix(format)
+
+    def eval_controls(self, qubit):
+        """Return True/False to indicate if the controls are satisfied."""
+        return all(qubit[bit] == self.control_value for bit in self.controls)
+
+    def decompose(self, **options):
+        """Decompose the controlled gate into CNOT and single qubits gates."""
+        if len(self.controls) == 1:
+            c = self.controls[0]
+            t = self.gate.targets[0]
+            if isinstance(self.gate, YGate):
+                g1 = PhaseGate(t)
+                g2 = CNotGate(c, t)
+                g3 = PhaseGate(t)
+                g4 = ZGate(t)
+                return g1*g2*g3*g4
+            if isinstance(self.gate, ZGate):
+                g1 = HadamardGate(t)
+                g2 = CNotGate(c, t)
+                g3 = HadamardGate(t)
+                return g1*g2*g3
+        else:
+            return self
+
+    #-------------------------------------------------------------------------
+    # Print methods
+    #-------------------------------------------------------------------------
+
+    def _print_label(self, printer, *args):
+        controls = self._print_sequence(self.controls, ',', printer, *args)
+        gate = printer._print(self.gate, *args)
+        return '(%s),%s' % (controls, gate)
+
+    def _pretty(self, printer, *args):
+        controls = self._print_sequence_pretty(
+            self.controls, ',', printer, *args)
+        gate = printer._print(self.gate)
+        gate_name = stringPict(self.gate_name)
+        first = self._print_subscript_pretty(gate_name, controls)
+        gate = self._print_parens_pretty(gate)
+        final = prettyForm(*first.right(gate))
+        return final
+
+    def _latex(self, printer, *args):
+        controls = self._print_sequence(self.controls, ',', printer, *args)
+        gate = printer._print(self.gate, *args)
+        return r'%s_{%s}{\left(%s\right)}' % \
+            (self.gate_name_latex, controls, gate)
+
+    def plot_gate(self, circ_plot, gate_idx):
+        """
+        Plot the controlled gate. If *simplify_cgate* is true, simplify
+        C-X and C-Z gates into their more familiar forms.
+        """
+        min_wire = int(_min(chain(self.controls, self.targets)))
+        max_wire = int(_max(chain(self.controls, self.targets)))
+        circ_plot.control_line(gate_idx, min_wire, max_wire)
+        for c in self.controls:
+            circ_plot.control_point(gate_idx, int(c))
+        if self.simplify_cgate:
+            if self.gate.gate_name == 'X':
+                self.gate.plot_gate_plus(circ_plot, gate_idx)
+            elif self.gate.gate_name == 'Z':
+                circ_plot.control_point(gate_idx, self.targets[0])
+            else:
+                self.gate.plot_gate(circ_plot, gate_idx)
+        else:
+            self.gate.plot_gate(circ_plot, gate_idx)
+
+    #-------------------------------------------------------------------------
+    # Miscellaneous
+    #-------------------------------------------------------------------------
+
+    def _eval_dagger(self):
+        if isinstance(self.gate, HermitianOperator):
+            return self
+        else:
+            return Gate._eval_dagger(self)
+
+    def _eval_inverse(self):
+        if isinstance(self.gate, HermitianOperator):
+            return self
+        else:
+            return Gate._eval_inverse(self)
+
+    def _eval_power(self, exp):
+        if isinstance(self.gate, HermitianOperator):
+            if exp == -1:
+                return Gate._eval_power(self, exp)
+            elif abs(exp) % 2 == 0:
+                return self*(Gate._eval_inverse(self))
+            else:
+                return self
+        else:
+            return Gate._eval_power(self, exp)
+
+class CGateS(CGate):
+    """Version of CGate that allows gate simplifications.
+    I.e. cnot looks like an oplus, cphase has dots, etc.
+    """
+    simplify_cgate=True
+
+
+class UGate(Gate):
+    """General gate specified by a set of targets and a target matrix.
+
+    Parameters
+    ----------
+    label : tuple
+        A tuple of the form (targets, U), where targets is a tuple of the
+        target qubits and U is a unitary matrix with dimension of
+        len(targets).
+    """
+    gate_name = 'U'
+    gate_name_latex = 'U'
+
+    #-------------------------------------------------------------------------
+    # Initialization
+    #-------------------------------------------------------------------------
+
+    @classmethod
+    def _eval_args(cls, args):
+        targets = args[0]
+        if not is_sequence(targets):
+            targets = (targets,)
+        targets = Gate._eval_args(targets)
+        _validate_targets_controls(targets)
+        mat = args[1]
+        if not isinstance(mat, MatrixBase):
+            raise TypeError('Matrix expected, got: %r' % mat)
+        #make sure this matrix is of a Basic type
+        mat = _sympify(mat)
+        dim = 2**len(targets)
+        if not all(dim == shape for shape in mat.shape):
+            raise IndexError(
+                'Number of targets must match the matrix size: %r %r' %
+                (targets, mat)
+            )
+        return (targets, mat)
+
+    @classmethod
+    def _eval_hilbert_space(cls, args):
+        """This returns the smallest possible Hilbert space."""
+        return ComplexSpace(2)**(_max(args[0]) + 1)
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def targets(self):
+        """A tuple of target qubits."""
+        return tuple(self.label[0])
+
+    #-------------------------------------------------------------------------
+    # Gate methods
+    #-------------------------------------------------------------------------
+
+    def get_target_matrix(self, format='sympy'):
+        """The matrix rep. of the target part of the gate.
+
+        Parameters
+        ----------
+        format : str
+            The format string ('sympy','numpy', etc.)
+        """
+        return self.label[1]
+
+    #-------------------------------------------------------------------------
+    # Print methods
+    #-------------------------------------------------------------------------
+    def _pretty(self, printer, *args):
+        targets = self._print_sequence_pretty(
+            self.targets, ',', printer, *args)
+        gate_name = stringPict(self.gate_name)
+        return self._print_subscript_pretty(gate_name, targets)
+
+    def _latex(self, printer, *args):
+        targets = self._print_sequence(self.targets, ',', printer, *args)
+        return r'%s_{%s}' % (self.gate_name_latex, targets)
+
+    def plot_gate(self, circ_plot, gate_idx):
+        circ_plot.one_qubit_box(
+            self.gate_name_plot,
+            gate_idx, int(self.targets[0])
+        )
+
+
+class OneQubitGate(Gate):
+    """A single qubit unitary gate base class."""
+
+    nqubits = _S.One
+
+    def plot_gate(self, circ_plot, gate_idx):
+        circ_plot.one_qubit_box(
+            self.gate_name_plot,
+            gate_idx, int(self.targets[0])
+        )
+
+    def _eval_commutator(self, other, **hints):
+        if isinstance(other, OneQubitGate):
+            if self.targets != other.targets or self.__class__ == other.__class__:
+                return _S.Zero
+        return Operator._eval_commutator(self, other, **hints)
+
+    def _eval_anticommutator(self, other, **hints):
+        if isinstance(other, OneQubitGate):
+            if self.targets != other.targets or self.__class__ == other.__class__:
+                return Integer(2)*self*other
+        return Operator._eval_anticommutator(self, other, **hints)
+
+
+class TwoQubitGate(Gate):
+    """A two qubit unitary gate base class."""
+
+    nqubits = Integer(2)
+
+#-----------------------------------------------------------------------------
+# Single Qubit Gates
+#-----------------------------------------------------------------------------
+
+
+class IdentityGate(OneQubitGate):
+    """The single qubit identity gate.
+
+    Parameters
+    ----------
+    target : int
+        The target qubit this gate will apply to.
+
+    Examples
+    ========
+
+    """
+    gate_name = '1'
+    gate_name_latex = '1'
+
+    # Short cut version of gate._apply_operator_Qubit
+    def _apply_operator_Qubit(self, qubits, **options):
+        # Check number of qubits this gate acts on (see gate._apply_operator_Qubit)
+        if qubits.nqubits < self.min_qubits:
+            raise QuantumError(
+                'Gate needs a minimum of %r qubits to act on, got: %r' %
+                (self.min_qubits, qubits.nqubits)
+            )
+        return qubits # no computation required for IdentityGate
+
+    def get_target_matrix(self, format='sympy'):
+        return matrix_cache.get_matrix('eye2', format)
+
+    def _eval_commutator(self, other, **hints):
+        return _S.Zero
+
+    def _eval_anticommutator(self, other, **hints):
+        return Integer(2)*other
+
+
+class HadamardGate(HermitianOperator, OneQubitGate):
+    """The single qubit Hadamard gate.
+
+    Parameters
+    ----------
+    target : int
+        The target qubit this gate will apply to.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.physics.quantum.qubit import Qubit
+    >>> from sympy.physics.quantum.gate import HadamardGate
+    >>> from sympy.physics.quantum.qapply import qapply
+    >>> qapply(HadamardGate(0)*Qubit('1'))
+    sqrt(2)*|0>/2 - sqrt(2)*|1>/2
+    >>> # Hadamard on bell state, applied on 2 qubits.
+    >>> psi = 1/sqrt(2)*(Qubit('00')+Qubit('11'))
+    >>> qapply(HadamardGate(0)*HadamardGate(1)*psi)
+    sqrt(2)*|00>/2 + sqrt(2)*|11>/2
+
+    """
+    gate_name = 'H'
+    gate_name_latex = 'H'
+
+    def get_target_matrix(self, format='sympy'):
+        if _normalized:
+            return matrix_cache.get_matrix('H', format)
+        else:
+            return matrix_cache.get_matrix('Hsqrt2', format)
+
+    def _eval_commutator_XGate(self, other, **hints):
+        return I*sqrt(2)*YGate(self.targets[0])
+
+    def _eval_commutator_YGate(self, other, **hints):
+        return I*sqrt(2)*(ZGate(self.targets[0]) - XGate(self.targets[0]))
+
+    def _eval_commutator_ZGate(self, other, **hints):
+        return -I*sqrt(2)*YGate(self.targets[0])
+
+    def _eval_anticommutator_XGate(self, other, **hints):
+        return sqrt(2)*IdentityGate(self.targets[0])
+
+    def _eval_anticommutator_YGate(self, other, **hints):
+        return _S.Zero
+
+    def _eval_anticommutator_ZGate(self, other, **hints):
+        return sqrt(2)*IdentityGate(self.targets[0])
+
+
+class XGate(HermitianOperator, OneQubitGate):
+    """The single qubit X, or NOT, gate.
+
+    Parameters
+    ----------
+    target : int
+        The target qubit this gate will apply to.
+
+    Examples
+    ========
+
+    """
+    gate_name = 'X'
+    gate_name_latex = 'X'
+
+    def get_target_matrix(self, format='sympy'):
+        return matrix_cache.get_matrix('X', format)
+
+    def plot_gate(self, circ_plot, gate_idx):
+        OneQubitGate.plot_gate(self,circ_plot,gate_idx)
+
+    def plot_gate_plus(self, circ_plot, gate_idx):
+        circ_plot.not_point(
+            gate_idx, int(self.label[0])
+        )
+
+    def _eval_commutator_YGate(self, other, **hints):
+        return Integer(2)*I*ZGate(self.targets[0])
+
+    def _eval_anticommutator_XGate(self, other, **hints):
+        return Integer(2)*IdentityGate(self.targets[0])
+
+    def _eval_anticommutator_YGate(self, other, **hints):
+        return _S.Zero
+
+    def _eval_anticommutator_ZGate(self, other, **hints):
+        return _S.Zero
+
+
+class YGate(HermitianOperator, OneQubitGate):
+    """The single qubit Y gate.
+
+    Parameters
+    ----------
+    target : int
+        The target qubit this gate will apply to.
+
+    Examples
+    ========
+
+    """
+    gate_name = 'Y'
+    gate_name_latex = 'Y'
+
+    def get_target_matrix(self, format='sympy'):
+        return matrix_cache.get_matrix('Y', format)
+
+    def _eval_commutator_ZGate(self, other, **hints):
+        return Integer(2)*I*XGate(self.targets[0])
+
+    def _eval_anticommutator_YGate(self, other, **hints):
+        return Integer(2)*IdentityGate(self.targets[0])
+
+    def _eval_anticommutator_ZGate(self, other, **hints):
+        return _S.Zero
+
+
+class ZGate(HermitianOperator, OneQubitGate):
+    """The single qubit Z gate.
+
+    Parameters
+    ----------
+    target : int
+        The target qubit this gate will apply to.
+
+    Examples
+    ========
+
+    """
+    gate_name = 'Z'
+    gate_name_latex = 'Z'
+
+    def get_target_matrix(self, format='sympy'):
+        return matrix_cache.get_matrix('Z', format)
+
+    def _eval_commutator_XGate(self, other, **hints):
+        return Integer(2)*I*YGate(self.targets[0])
+
+    def _eval_anticommutator_YGate(self, other, **hints):
+        return _S.Zero
+
+
+class PhaseGate(OneQubitGate):
+    """The single qubit phase, or S, gate.
+
+    This gate rotates the phase of the state by pi/2 if the state is ``|1>`` and
+    does nothing if the state is ``|0>``.
+
+    Parameters
+    ----------
+    target : int
+        The target qubit this gate will apply to.
+
+    Examples
+    ========
+
+    """
+    gate_name = 'S'
+    gate_name_latex = 'S'
+
+    def get_target_matrix(self, format='sympy'):
+        return matrix_cache.get_matrix('S', format)
+
+    def _eval_commutator_ZGate(self, other, **hints):
+        return _S.Zero
+
+    def _eval_commutator_TGate(self, other, **hints):
+        return _S.Zero
+
+
+class TGate(OneQubitGate):
+    """The single qubit pi/8 gate.
+
+    This gate rotates the phase of the state by pi/4 if the state is ``|1>`` and
+    does nothing if the state is ``|0>``.
+
+    Parameters
+    ----------
+    target : int
+        The target qubit this gate will apply to.
+
+    Examples
+    ========
+
+    """
+    gate_name = 'T'
+    gate_name_latex = 'T'
+
+    def get_target_matrix(self, format='sympy'):
+        return matrix_cache.get_matrix('T', format)
+
+    def _eval_commutator_ZGate(self, other, **hints):
+        return _S.Zero
+
+    def _eval_commutator_PhaseGate(self, other, **hints):
+        return _S.Zero
+
+
+# Aliases for gate names.
+H = HadamardGate
+X = XGate
+Y = YGate
+Z = ZGate
+T = TGate
+Phase = S = PhaseGate
+
+
+#-----------------------------------------------------------------------------
+# 2 Qubit Gates
+#-----------------------------------------------------------------------------
+
+
+class CNotGate(HermitianOperator, CGate, TwoQubitGate):
+    """Two qubit controlled-NOT.
+
+    This gate performs the NOT or X gate on the target qubit if the control
+    qubits all have the value 1.
+
+    Parameters
+    ----------
+    label : tuple
+        A tuple of the form (control, target).
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.gate import CNOT
+    >>> from sympy.physics.quantum.qapply import qapply
+    >>> from sympy.physics.quantum.qubit import Qubit
+    >>> c = CNOT(1,0)
+    >>> qapply(c*Qubit('10')) # note that qubits are indexed from right to left
+    |11>
+
+    """
+    gate_name = 'CNOT'
+    gate_name_latex = r'\text{CNOT}'
+    simplify_cgate = True
+
+    #-------------------------------------------------------------------------
+    # Initialization
+    #-------------------------------------------------------------------------
+
+    @classmethod
+    def _eval_args(cls, args):
+        args = Gate._eval_args(args)
+        return args
+
+    @classmethod
+    def _eval_hilbert_space(cls, args):
+        """This returns the smallest possible Hilbert space."""
+        return ComplexSpace(2)**(_max(args) + 1)
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def min_qubits(self):
+        """The minimum number of qubits this gate needs to act on."""
+        return _max(self.label) + 1
+
+    @property
+    def targets(self):
+        """A tuple of target qubits."""
+        return (self.label[1],)
+
+    @property
+    def controls(self):
+        """A tuple of control qubits."""
+        return (self.label[0],)
+
+    @property
+    def gate(self):
+        """The non-controlled gate that will be applied to the targets."""
+        return XGate(self.label[1])
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    # The default printing of Gate works better than those of CGate, so we
+    # go around the overridden methods in CGate.
+
+    def _print_label(self, printer, *args):
+        return Gate._print_label(self, printer, *args)
+
+    def _pretty(self, printer, *args):
+        return Gate._pretty(self, printer, *args)
+
+    def _latex(self, printer, *args):
+        return Gate._latex(self, printer, *args)
+
+    #-------------------------------------------------------------------------
+    # Commutator/AntiCommutator
+    #-------------------------------------------------------------------------
+
+    def _eval_commutator_ZGate(self, other, **hints):
+        """[CNOT(i, j), Z(i)] == 0."""
+        if self.controls[0] == other.targets[0]:
+            return _S.Zero
+        else:
+            raise NotImplementedError('Commutator not implemented: %r' % other)
+
+    def _eval_commutator_TGate(self, other, **hints):
+        """[CNOT(i, j), T(i)] == 0."""
+        return self._eval_commutator_ZGate(other, **hints)
+
+    def _eval_commutator_PhaseGate(self, other, **hints):
+        """[CNOT(i, j), S(i)] == 0."""
+        return self._eval_commutator_ZGate(other, **hints)
+
+    def _eval_commutator_XGate(self, other, **hints):
+        """[CNOT(i, j), X(j)] == 0."""
+        if self.targets[0] == other.targets[0]:
+            return _S.Zero
+        else:
+            raise NotImplementedError('Commutator not implemented: %r' % other)
+
+    def _eval_commutator_CNotGate(self, other, **hints):
+        """[CNOT(i, j), CNOT(i,k)] == 0."""
+        if self.controls[0] == other.controls[0]:
+            return _S.Zero
+        else:
+            raise NotImplementedError('Commutator not implemented: %r' % other)
+
+
+class SwapGate(TwoQubitGate):
+    """Two qubit SWAP gate.
+
+    This gate swap the values of the two qubits.
+
+    Parameters
+    ----------
+    label : tuple
+        A tuple of the form (target1, target2).
+
+    Examples
+    ========
+
+    """
+    gate_name = 'SWAP'
+    gate_name_latex = r'\text{SWAP}'
+
+    def get_target_matrix(self, format='sympy'):
+        return matrix_cache.get_matrix('SWAP', format)
+
+    def decompose(self, **options):
+        """Decompose the SWAP gate into CNOT gates."""
+        i, j = self.targets[0], self.targets[1]
+        g1 = CNotGate(i, j)
+        g2 = CNotGate(j, i)
+        return g1*g2*g1
+
+    def plot_gate(self, circ_plot, gate_idx):
+        min_wire = int(_min(self.targets))
+        max_wire = int(_max(self.targets))
+        circ_plot.control_line(gate_idx, min_wire, max_wire)
+        circ_plot.swap_point(gate_idx, min_wire)
+        circ_plot.swap_point(gate_idx, max_wire)
+
+    def _represent_ZGate(self, basis, **options):
+        """Represent the SWAP gate in the computational basis.
+
+        The following representation is used to compute this:
+
+        SWAP = |1><1|x|1><1| + |0><0|x|0><0| + |1><0|x|0><1| + |0><1|x|1><0|
+        """
+        format = options.get('format', 'sympy')
+        targets = [int(t) for t in self.targets]
+        min_target = _min(targets)
+        max_target = _max(targets)
+        nqubits = options.get('nqubits', self.min_qubits)
+
+        op01 = matrix_cache.get_matrix('op01', format)
+        op10 = matrix_cache.get_matrix('op10', format)
+        op11 = matrix_cache.get_matrix('op11', format)
+        op00 = matrix_cache.get_matrix('op00', format)
+        eye2 = matrix_cache.get_matrix('eye2', format)
+
+        result = None
+        for i, j in ((op01, op10), (op10, op01), (op00, op00), (op11, op11)):
+            product = nqubits*[eye2]
+            product[nqubits - min_target - 1] = i
+            product[nqubits - max_target - 1] = j
+            new_result = matrix_tensor_product(*product)
+            if result is None:
+                result = new_result
+            else:
+                result = result + new_result
+
+        return result
+
+
+# Aliases for gate names.
+CNOT = CNotGate
+SWAP = SwapGate
+def CPHASE(a,b): return CGateS((a,),Z(b))
+
+
+#-----------------------------------------------------------------------------
+# Represent
+#-----------------------------------------------------------------------------
+
+
+def represent_zbasis(controls, targets, target_matrix, nqubits, format='sympy'):
+    """Represent a gate with controls, targets and target_matrix.
+
+    This function does the low-level work of representing gates as matrices
+    in the standard computational basis (ZGate). Currently, we support two
+    main cases:
+
+    1. One target qubit and no control qubits.
+    2. One target qubits and multiple control qubits.
+
+    For the base of multiple controls, we use the following expression [1]:
+
+    1_{2**n} + (|1><1|)^{(n-1)} x (target-matrix - 1_{2})
+
+    Parameters
+    ----------
+    controls : list, tuple
+        A sequence of control qubits.
+    targets : list, tuple
+        A sequence of target qubits.
+    target_matrix : sympy.Matrix, numpy.matrix, scipy.sparse
+        The matrix form of the transformation to be performed on the target
+        qubits.  The format of this matrix must match that passed into
+        the `format` argument.
+    nqubits : int
+        The total number of qubits used for the representation.
+    format : str
+        The format of the final matrix ('sympy', 'numpy', 'scipy.sparse').
+
+    Examples
+    ========
+
+    References
+    ----------
+    [1] http://www.johnlapeyre.com/qinf/qinf_html/node6.html.
+    """
+    controls = [int(x) for x in controls]
+    targets = [int(x) for x in targets]
+    nqubits = int(nqubits)
+
+    # This checks for the format as well.
+    op11 = matrix_cache.get_matrix('op11', format)
+    eye2 = matrix_cache.get_matrix('eye2', format)
+
+    # Plain single qubit case
+    if len(controls) == 0 and len(targets) == 1:
+        product = []
+        bit = targets[0]
+        # Fill product with [I1,Gate,I2] such that the unitaries,
+        # I, cause the gate to be applied to the correct Qubit
+        if bit != nqubits - 1:
+            product.append(matrix_eye(2**(nqubits - bit - 1), format=format))
+        product.append(target_matrix)
+        if bit != 0:
+            product.append(matrix_eye(2**bit, format=format))
+        return matrix_tensor_product(*product)
+
+    # Single target, multiple controls.
+    elif len(targets) == 1 and len(controls) >= 1:
+        target = targets[0]
+
+        # Build the non-trivial part.
+        product2 = []
+        for i in range(nqubits):
+            product2.append(matrix_eye(2, format=format))
+        for control in controls:
+            product2[nqubits - 1 - control] = op11
+        product2[nqubits - 1 - target] = target_matrix - eye2
+
+        return matrix_eye(2**nqubits, format=format) + \
+            matrix_tensor_product(*product2)
+
+    # Multi-target, multi-control is not yet implemented.
+    else:
+        raise NotImplementedError(
+            'The representation of multi-target, multi-control gates '
+            'is not implemented.'
+        )
+
+
+#-----------------------------------------------------------------------------
+# Gate manipulation functions.
+#-----------------------------------------------------------------------------
+
+
+def gate_simp(circuit):
+    """Simplifies gates symbolically
+
+    It first sorts gates using gate_sort. It then applies basic
+    simplification rules to the circuit, e.g., XGate**2 = Identity
+    """
+
+    # Bubble sort out gates that commute.
+    circuit = gate_sort(circuit)
+
+    # Do simplifications by subing a simplification into the first element
+    # which can be simplified. We recursively call gate_simp with new circuit
+    # as input more simplifications exist.
+    if isinstance(circuit, Add):
+        return sum(gate_simp(t) for t in circuit.args)
+    elif isinstance(circuit, Mul):
+        circuit_args = circuit.args
+    elif isinstance(circuit, Pow):
+        b, e = circuit.as_base_exp()
+        circuit_args = (gate_simp(b)**e,)
+    else:
+        return circuit
+
+    # Iterate through each element in circuit, simplify if possible.
+    for i in range(len(circuit_args)):
+        # H,X,Y or Z squared is 1.
+        # T**2 = S, S**2 = Z
+        if isinstance(circuit_args[i], Pow):
+            if isinstance(circuit_args[i].base,
+                (HadamardGate, XGate, YGate, ZGate)) \
+                    and isinstance(circuit_args[i].exp, Number):
+                # Build a new circuit taking replacing the
+                # H,X,Y,Z squared with one.
+                newargs = (circuit_args[:i] +
+                          (circuit_args[i].base**(circuit_args[i].exp % 2),) +
+                           circuit_args[i + 1:])
+                # Recursively simplify the new circuit.
+                circuit = gate_simp(Mul(*newargs))
+                break
+            elif isinstance(circuit_args[i].base, PhaseGate):
+                # Build a new circuit taking old circuit but splicing
+                # in simplification.
+                newargs = circuit_args[:i]
+                # Replace PhaseGate**2 with ZGate.
+                newargs = newargs + (ZGate(circuit_args[i].base.args[0])**
+                (Integer(circuit_args[i].exp/2)), circuit_args[i].base**
+                (circuit_args[i].exp % 2))
+                # Append the last elements.
+                newargs = newargs + circuit_args[i + 1:]
+                # Recursively simplify the new circuit.
+                circuit = gate_simp(Mul(*newargs))
+                break
+            elif isinstance(circuit_args[i].base, TGate):
+                # Build a new circuit taking all the old elements.
+                newargs = circuit_args[:i]
+
+                # Put an Phasegate in place of any TGate**2.
+                newargs = newargs + (PhaseGate(circuit_args[i].base.args[0])**
+                Integer(circuit_args[i].exp/2), circuit_args[i].base**
+                    (circuit_args[i].exp % 2))
+
+                # Append the last elements.
+                newargs = newargs + circuit_args[i + 1:]
+                # Recursively simplify the new circuit.
+                circuit = gate_simp(Mul(*newargs))
+                break
+    return circuit
+
+
+def gate_sort(circuit):
+    """Sorts the gates while keeping track of commutation relations
+
+    This function uses a bubble sort to rearrange the order of gate
+    application. Keeps track of Quantum computations special commutation
+    relations (e.g. things that apply to the same Qubit do not commute with
+    each other)
+
+    circuit is the Mul of gates that are to be sorted.
+    """
+    # Make sure we have an Add or Mul.
+    if isinstance(circuit, Add):
+        return sum(gate_sort(t) for t in circuit.args)
+    if isinstance(circuit, Pow):
+        return gate_sort(circuit.base)**circuit.exp
+    elif isinstance(circuit, Gate):
+        return circuit
+    if not isinstance(circuit, Mul):
+        return circuit
+
+    changes = True
+    while changes:
+        changes = False
+        circ_array = circuit.args
+        for i in range(len(circ_array) - 1):
+            # Go through each element and switch ones that are in wrong order
+            if isinstance(circ_array[i], (Gate, Pow)) and \
+                    isinstance(circ_array[i + 1], (Gate, Pow)):
+                # If we have a Pow object, look at only the base
+                first_base, first_exp = circ_array[i].as_base_exp()
+                second_base, second_exp = circ_array[i + 1].as_base_exp()
+
+                # Use SymPy's hash based sorting. This is not mathematical
+                # sorting, but is rather based on comparing hashes of objects.
+                # See Basic.compare for details.
+                if first_base.compare(second_base) > 0:
+                    if Commutator(first_base, second_base).doit() == 0:
+                        new_args = (circuit.args[:i] + (circuit.args[i + 1],) +
+                                   (circuit.args[i],) + circuit.args[i + 2:])
+                        circuit = Mul(*new_args)
+                        changes = True
+                        break
+                    if AntiCommutator(first_base, second_base).doit() == 0:
+                        new_args = (circuit.args[:i] + (circuit.args[i + 1],) +
+                                   (circuit.args[i],) + circuit.args[i + 2:])
+                        sign = _S.NegativeOne**(first_exp*second_exp)
+                        circuit = sign*Mul(*new_args)
+                        changes = True
+                        break
+    return circuit
+
+
+#-----------------------------------------------------------------------------
+# Utility functions
+#-----------------------------------------------------------------------------
+
+
+def random_circuit(ngates, nqubits, gate_space=(X, Y, Z, S, T, H, CNOT, SWAP)):
+    """Return a random circuit of ngates and nqubits.
+
+    This uses an equally weighted sample of (X, Y, Z, S, T, H, CNOT, SWAP)
+    gates.
+
+    Parameters
+    ----------
+    ngates : int
+        The number of gates in the circuit.
+    nqubits : int
+        The number of qubits in the circuit.
+    gate_space : tuple
+        A tuple of the gate classes that will be used in the circuit.
+        Repeating gate classes multiple times in this tuple will increase
+        the frequency they appear in the random circuit.
+    """
+    qubit_space = range(nqubits)
+    result = []
+    for i in range(ngates):
+        g = random.choice(gate_space)
+        if g == CNotGate or g == SwapGate:
+            qubits = random.sample(qubit_space, 2)
+            g = g(*qubits)
+        else:
+            qubit = random.choice(qubit_space)
+            g = g(qubit)
+        result.append(g)
+    return Mul(*result)
+
+
+def zx_basis_transform(self, format='sympy'):
+    """Transformation matrix from Z to X basis."""
+    return matrix_cache.get_matrix('ZX', format)
+
+
+def zy_basis_transform(self, format='sympy'):
+    """Transformation matrix from Z to Y basis."""
+    return matrix_cache.get_matrix('ZY', format)

venv/lib/python3.10/site-packages/sympy/physics/quantum/grover.py

@@ -0,0 +1,345 @@
+"""Grover's algorithm and helper functions.
+
+Todo:
+
+* W gate construction (or perhaps -W gate based on Mermin's book)
+* Generalize the algorithm for an unknown function that returns 1 on multiple
+  qubit states, not just one.
+* Implement _represent_ZGate in OracleGate
+"""
+
+from sympy.core.numbers import pi
+from sympy.core.sympify import sympify
+from sympy.core.basic import Atom
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import eye
+from sympy.core.numbers import NegativeOne
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.qexpr import QuantumError
+from sympy.physics.quantum.hilbert import ComplexSpace
+from sympy.physics.quantum.operator import UnitaryOperator
+from sympy.physics.quantum.gate import Gate
+from sympy.physics.quantum.qubit import IntQubit
+
+__all__ = [
+    'OracleGate',
+    'WGate',
+    'superposition_basis',
+    'grover_iteration',
+    'apply_grover'
+]
+
+
+def superposition_basis(nqubits):
+    """Creates an equal superposition of the computational basis.
+
+    Parameters
+    ==========
+
+    nqubits : int
+        The number of qubits.
+
+    Returns
+    =======
+
+    state : Qubit
+        An equal superposition of the computational basis with nqubits.
+
+    Examples
+    ========
+
+    Create an equal superposition of 2 qubits::
+
+        >>> from sympy.physics.quantum.grover import superposition_basis
+        >>> superposition_basis(2)
+        |0>/2 + |1>/2 + |2>/2 + |3>/2
+    """
+
+    amp = 1/sqrt(2**nqubits)
+    return sum([amp*IntQubit(n, nqubits=nqubits) for n in range(2**nqubits)])
+
+class OracleGateFunction(Atom):
+    """Wrapper for python functions used in `OracleGate`s"""
+
+    def __new__(cls, function):
+        if not callable(function):
+            raise TypeError('Callable expected, got: %r' % function)
+        obj = Atom.__new__(cls)
+        obj.function = function
+        return obj
+
+    def _hashable_content(self):
+        return type(self), self.function
+
+    def __call__(self, *args):
+        return self.function(*args)
+
+
+class OracleGate(Gate):
+    """A black box gate.
+
+    The gate marks the desired qubits of an unknown function by flipping
+    the sign of the qubits.  The unknown function returns true when it
+    finds its desired qubits and false otherwise.
+
+    Parameters
+    ==========
+
+    qubits : int
+        Number of qubits.
+
+    oracle : callable
+        A callable function that returns a boolean on a computational basis.
+
+    Examples
+    ========
+
+    Apply an Oracle gate that flips the sign of ``|2>`` on different qubits::
+
+        >>> from sympy.physics.quantum.qubit import IntQubit
+        >>> from sympy.physics.quantum.qapply import qapply
+        >>> from sympy.physics.quantum.grover import OracleGate
+        >>> f = lambda qubits: qubits == IntQubit(2)
+        >>> v = OracleGate(2, f)
+        >>> qapply(v*IntQubit(2))
+        -|2>
+        >>> qapply(v*IntQubit(3))
+        |3>
+    """
+
+    gate_name = 'V'
+    gate_name_latex = 'V'
+
+    #-------------------------------------------------------------------------
+    # Initialization/creation
+    #-------------------------------------------------------------------------
+
+    @classmethod
+    def _eval_args(cls, args):
+        if len(args) != 2:
+            raise QuantumError(
+                'Insufficient/excessive arguments to Oracle.  Please ' +
+                'supply the number of qubits and an unknown function.'
+            )
+        sub_args = (args[0],)
+        sub_args = UnitaryOperator._eval_args(sub_args)
+        if not sub_args[0].is_Integer:
+            raise TypeError('Integer expected, got: %r' % sub_args[0])
+
+        function = args[1]
+        if not isinstance(function, OracleGateFunction):
+            function = OracleGateFunction(function)
+
+        return (sub_args[0], function)
+
+    @classmethod
+    def _eval_hilbert_space(cls, args):
+        """This returns the smallest possible Hilbert space."""
+        return ComplexSpace(2)**args[0]
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def search_function(self):
+        """The unknown function that helps find the sought after qubits."""
+        return self.label[1]
+
+    @property
+    def targets(self):
+        """A tuple of target qubits."""
+        return sympify(tuple(range(self.args[0])))
+
+    #-------------------------------------------------------------------------
+    # Apply
+    #-------------------------------------------------------------------------
+
+    def _apply_operator_Qubit(self, qubits, **options):
+        """Apply this operator to a Qubit subclass.
+
+        Parameters
+        ==========
+
+        qubits : Qubit
+            The qubit subclass to apply this operator to.
+
+        Returns
+        =======
+
+        state : Expr
+            The resulting quantum state.
+        """
+        if qubits.nqubits != self.nqubits:
+            raise QuantumError(
+                'OracleGate operates on %r qubits, got: %r'
+                % (self.nqubits, qubits.nqubits)
+            )
+        # If function returns 1 on qubits
+            # return the negative of the qubits (flip the sign)
+        if self.search_function(qubits):
+            return -qubits
+        else:
+            return qubits
+
+    #-------------------------------------------------------------------------
+    # Represent
+    #-------------------------------------------------------------------------
+
+    def _represent_ZGate(self, basis, **options):
+        """
+        Represent the OracleGate in the computational basis.
+        """
+        nbasis = 2**self.nqubits  # compute it only once
+        matrixOracle = eye(nbasis)
+        # Flip the sign given the output of the oracle function
+        for i in range(nbasis):
+            if self.search_function(IntQubit(i, nqubits=self.nqubits)):
+                matrixOracle[i, i] = NegativeOne()
+        return matrixOracle
+
+
+class WGate(Gate):
+    """General n qubit W Gate in Grover's algorithm.
+
+    The gate performs the operation ``2|phi><phi| - 1`` on some qubits.
+    ``|phi> = (tensor product of n Hadamards)*(|0> with n qubits)``
+
+    Parameters
+    ==========
+
+    nqubits : int
+        The number of qubits to operate on
+
+    """
+
+    gate_name = 'W'
+    gate_name_latex = 'W'
+
+    @classmethod
+    def _eval_args(cls, args):
+        if len(args) != 1:
+            raise QuantumError(
+                'Insufficient/excessive arguments to W gate.  Please ' +
+                'supply the number of qubits to operate on.'
+            )
+        args = UnitaryOperator._eval_args(args)
+        if not args[0].is_Integer:
+            raise TypeError('Integer expected, got: %r' % args[0])
+        return args
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def targets(self):
+        return sympify(tuple(reversed(range(self.args[0]))))
+
+    #-------------------------------------------------------------------------
+    # Apply
+    #-------------------------------------------------------------------------
+
+    def _apply_operator_Qubit(self, qubits, **options):
+        """
+        qubits: a set of qubits (Qubit)
+        Returns: quantum object (quantum expression - QExpr)
+        """
+        if qubits.nqubits != self.nqubits:
+            raise QuantumError(
+                'WGate operates on %r qubits, got: %r'
+                % (self.nqubits, qubits.nqubits)
+            )
+
+        # See 'Quantum Computer Science' by David Mermin p.92 -> W|a> result
+        # Return (2/(sqrt(2^n)))|phi> - |a> where |a> is the current basis
+        # state and phi is the superposition of basis states (see function
+        # create_computational_basis above)
+        basis_states = superposition_basis(self.nqubits)
+        change_to_basis = (2/sqrt(2**self.nqubits))*basis_states
+        return change_to_basis - qubits
+
+
+def grover_iteration(qstate, oracle):
+    """Applies one application of the Oracle and W Gate, WV.
+
+    Parameters
+    ==========
+
+    qstate : Qubit
+        A superposition of qubits.
+    oracle : OracleGate
+        The black box operator that flips the sign of the desired basis qubits.
+
+    Returns
+    =======
+
+    Qubit : The qubits after applying the Oracle and W gate.
+
+    Examples
+    ========
+
+    Perform one iteration of grover's algorithm to see a phase change::
+
+        >>> from sympy.physics.quantum.qapply import qapply
+        >>> from sympy.physics.quantum.qubit import IntQubit
+        >>> from sympy.physics.quantum.grover import OracleGate
+        >>> from sympy.physics.quantum.grover import superposition_basis
+        >>> from sympy.physics.quantum.grover import grover_iteration
+        >>> numqubits = 2
+        >>> basis_states = superposition_basis(numqubits)
+        >>> f = lambda qubits: qubits == IntQubit(2)
+        >>> v = OracleGate(numqubits, f)
+        >>> qapply(grover_iteration(basis_states, v))
+        |2>
+
+    """
+    wgate = WGate(oracle.nqubits)
+    return wgate*oracle*qstate
+
+
+def apply_grover(oracle, nqubits, iterations=None):
+    """Applies grover's algorithm.
+
+    Parameters
+    ==========
+
+    oracle : callable
+        The unknown callable function that returns true when applied to the
+        desired qubits and false otherwise.
+
+    Returns
+    =======
+
+    state : Expr
+        The resulting state after Grover's algorithm has been iterated.
+
+    Examples
+    ========
+
+    Apply grover's algorithm to an even superposition of 2 qubits::
+
+        >>> from sympy.physics.quantum.qapply import qapply
+        >>> from sympy.physics.quantum.qubit import IntQubit
+        >>> from sympy.physics.quantum.grover import apply_grover
+        >>> f = lambda qubits: qubits == IntQubit(2)
+        >>> qapply(apply_grover(f, 2))
+        |2>
+
+    """
+    if nqubits <= 0:
+        raise QuantumError(
+            'Grover\'s algorithm needs nqubits > 0, received %r qubits'
+            % nqubits
+        )
+    if iterations is None:
+        iterations = floor(sqrt(2**nqubits)*(pi/4))
+
+    v = OracleGate(nqubits, oracle)
+    iterated = superposition_basis(nqubits)
+    for iter in range(iterations):
+        iterated = grover_iteration(iterated, v)
+        iterated = qapply(iterated)
+
+    return iterated

venv/lib/python3.10/site-packages/sympy/physics/quantum/identitysearch.py

@@ -0,0 +1,853 @@
+from collections import deque
+from sympy.core.random import randint
+
+from sympy.external import import_module
+from sympy.core.basic import Basic
+from sympy.core.mul import Mul
+from sympy.core.numbers import Number, equal_valued
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.physics.quantum.represent import represent
+from sympy.physics.quantum.dagger import Dagger
+
+__all__ = [
+    # Public interfaces
+    'generate_gate_rules',
+    'generate_equivalent_ids',
+    'GateIdentity',
+    'bfs_identity_search',
+    'random_identity_search',
+
+    # "Private" functions
+    'is_scalar_sparse_matrix',
+    'is_scalar_nonsparse_matrix',
+    'is_degenerate',
+    'is_reducible',
+]
+
+np = import_module('numpy')
+scipy = import_module('scipy', import_kwargs={'fromlist': ['sparse']})
+
+
+def is_scalar_sparse_matrix(circuit, nqubits, identity_only, eps=1e-11):
+    """Checks if a given scipy.sparse matrix is a scalar matrix.
+
+    A scalar matrix is such that B = bI, where B is the scalar
+    matrix, b is some scalar multiple, and I is the identity
+    matrix.  A scalar matrix would have only the element b along
+    it's main diagonal and zeroes elsewhere.
+
+    Parameters
+    ==========
+
+    circuit : Gate tuple
+        Sequence of quantum gates representing a quantum circuit
+    nqubits : int
+        Number of qubits in the circuit
+    identity_only : bool
+        Check for only identity matrices
+    eps : number
+        The tolerance value for zeroing out elements in the matrix.
+        Values in the range [-eps, +eps] will be changed to a zero.
+    """
+
+    if not np or not scipy:
+        pass
+
+    matrix = represent(Mul(*circuit), nqubits=nqubits,
+                       format='scipy.sparse')
+
+    # In some cases, represent returns a 1D scalar value in place
+    # of a multi-dimensional scalar matrix
+    if (isinstance(matrix, int)):
+        return matrix == 1 if identity_only else True
+
+    # If represent returns a matrix, check if the matrix is diagonal
+    # and if every item along the diagonal is the same
+    else:
+        # Due to floating pointing operations, must zero out
+        # elements that are "very" small in the dense matrix
+        # See parameter for default value.
+
+        # Get the ndarray version of the dense matrix
+        dense_matrix = matrix.todense().getA()
+        # Since complex values can't be compared, must split
+        # the matrix into real and imaginary components
+        # Find the real values in between -eps and eps
+        bool_real = np.logical_and(dense_matrix.real > -eps,
+                                   dense_matrix.real < eps)
+        # Find the imaginary values between -eps and eps
+        bool_imag = np.logical_and(dense_matrix.imag > -eps,
+                                   dense_matrix.imag < eps)
+        # Replaces values between -eps and eps with 0
+        corrected_real = np.where(bool_real, 0.0, dense_matrix.real)
+        corrected_imag = np.where(bool_imag, 0.0, dense_matrix.imag)
+        # Convert the matrix with real values into imaginary values
+        corrected_imag = corrected_imag * complex(1j)
+        # Recombine the real and imaginary components
+        corrected_dense = corrected_real + corrected_imag
+
+        # Check if it's diagonal
+        row_indices = corrected_dense.nonzero()[0]
+        col_indices = corrected_dense.nonzero()[1]
+        # Check if the rows indices and columns indices are the same
+        # If they match, then matrix only contains elements along diagonal
+        bool_indices = row_indices == col_indices
+        is_diagonal = bool_indices.all()
+
+        first_element = corrected_dense[0][0]
+        # If the first element is a zero, then can't rescale matrix
+        # and definitely not diagonal
+        if (first_element == 0.0 + 0.0j):
+            return False
+
+        # The dimensions of the dense matrix should still
+        # be 2^nqubits if there are elements all along the
+        # the main diagonal
+        trace_of_corrected = (corrected_dense/first_element).trace()
+        expected_trace = pow(2, nqubits)
+        has_correct_trace = trace_of_corrected == expected_trace
+
+        # If only looking for identity matrices
+        # first element must be a 1
+        real_is_one = abs(first_element.real - 1.0) < eps
+        imag_is_zero = abs(first_element.imag) < eps
+        is_one = real_is_one and imag_is_zero
+        is_identity = is_one if identity_only else True
+        return bool(is_diagonal and has_correct_trace and is_identity)
+
+
+def is_scalar_nonsparse_matrix(circuit, nqubits, identity_only, eps=None):
+    """Checks if a given circuit, in matrix form, is equivalent to
+    a scalar value.
+
+    Parameters
+    ==========
+
+    circuit : Gate tuple
+        Sequence of quantum gates representing a quantum circuit
+    nqubits : int
+        Number of qubits in the circuit
+    identity_only : bool
+        Check for only identity matrices
+    eps : number
+        This argument is ignored. It is just for signature compatibility with
+        is_scalar_sparse_matrix.
+
+    Note: Used in situations when is_scalar_sparse_matrix has bugs
+    """
+
+    matrix = represent(Mul(*circuit), nqubits=nqubits)
+
+    # In some cases, represent returns a 1D scalar value in place
+    # of a multi-dimensional scalar matrix
+    if (isinstance(matrix, Number)):
+        return matrix == 1 if identity_only else True
+
+    # If represent returns a matrix, check if the matrix is diagonal
+    # and if every item along the diagonal is the same
+    else:
+        # Added up the diagonal elements
+        matrix_trace = matrix.trace()
+        # Divide the trace by the first element in the matrix
+        # if matrix is not required to be the identity matrix
+        adjusted_matrix_trace = (matrix_trace/matrix[0]
+                                 if not identity_only
+                                 else matrix_trace)
+
+        is_identity = equal_valued(matrix[0], 1) if identity_only else True
+
+        has_correct_trace = adjusted_matrix_trace == pow(2, nqubits)
+
+        # The matrix is scalar if it's diagonal and the adjusted trace
+        # value is equal to 2^nqubits
+        return bool(
+            matrix.is_diagonal() and has_correct_trace and is_identity)
+
+if np and scipy:
+    is_scalar_matrix = is_scalar_sparse_matrix
+else:
+    is_scalar_matrix = is_scalar_nonsparse_matrix
+
+
+def _get_min_qubits(a_gate):
+    if isinstance(a_gate, Pow):
+        return a_gate.base.min_qubits
+    else:
+        return a_gate.min_qubits
+
+
+def ll_op(left, right):
+    """Perform a LL operation.
+
+    A LL operation multiplies both left and right circuits
+    with the dagger of the left circuit's leftmost gate, and
+    the dagger is multiplied on the left side of both circuits.
+
+    If a LL is possible, it returns the new gate rule as a
+    2-tuple (LHS, RHS), where LHS is the left circuit and
+    and RHS is the right circuit of the new rule.
+    If a LL is not possible, None is returned.
+
+    Parameters
+    ==========
+
+    left : Gate tuple
+        The left circuit of a gate rule expression.
+    right : Gate tuple
+        The right circuit of a gate rule expression.
+
+    Examples
+    ========
+
+    Generate a new gate rule using a LL operation:
+
+    >>> from sympy.physics.quantum.identitysearch import ll_op
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> ll_op((x, y, z), ())
+    ((Y(0), Z(0)), (X(0),))
+
+    >>> ll_op((y, z), (x,))
+    ((Z(0),), (Y(0), X(0)))
+    """
+
+    if (len(left) > 0):
+        ll_gate = left[0]
+        ll_gate_is_unitary = is_scalar_matrix(
+            (Dagger(ll_gate), ll_gate), _get_min_qubits(ll_gate), True)
+
+    if (len(left) > 0 and ll_gate_is_unitary):
+        # Get the new left side w/o the leftmost gate
+        new_left = left[1:len(left)]
+        # Add the leftmost gate to the left position on the right side
+        new_right = (Dagger(ll_gate),) + right
+        # Return the new gate rule
+        return (new_left, new_right)
+
+    return None
+
+
+def lr_op(left, right):
+    """Perform a LR operation.
+
+    A LR operation multiplies both left and right circuits
+    with the dagger of the left circuit's rightmost gate, and
+    the dagger is multiplied on the right side of both circuits.
+
+    If a LR is possible, it returns the new gate rule as a
+    2-tuple (LHS, RHS), where LHS is the left circuit and
+    and RHS is the right circuit of the new rule.
+    If a LR is not possible, None is returned.
+
+    Parameters
+    ==========
+
+    left : Gate tuple
+        The left circuit of a gate rule expression.
+    right : Gate tuple
+        The right circuit of a gate rule expression.
+
+    Examples
+    ========
+
+    Generate a new gate rule using a LR operation:
+
+    >>> from sympy.physics.quantum.identitysearch import lr_op
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> lr_op((x, y, z), ())
+    ((X(0), Y(0)), (Z(0),))
+
+    >>> lr_op((x, y), (z,))
+    ((X(0),), (Z(0), Y(0)))
+    """
+
+    if (len(left) > 0):
+        lr_gate = left[len(left) - 1]
+        lr_gate_is_unitary = is_scalar_matrix(
+            (Dagger(lr_gate), lr_gate), _get_min_qubits(lr_gate), True)
+
+    if (len(left) > 0 and lr_gate_is_unitary):
+        # Get the new left side w/o the rightmost gate
+        new_left = left[0:len(left) - 1]
+        # Add the rightmost gate to the right position on the right side
+        new_right = right + (Dagger(lr_gate),)
+        # Return the new gate rule
+        return (new_left, new_right)
+
+    return None
+
+
+def rl_op(left, right):
+    """Perform a RL operation.
+
+    A RL operation multiplies both left and right circuits
+    with the dagger of the right circuit's leftmost gate, and
+    the dagger is multiplied on the left side of both circuits.
+
+    If a RL is possible, it returns the new gate rule as a
+    2-tuple (LHS, RHS), where LHS is the left circuit and
+    and RHS is the right circuit of the new rule.
+    If a RL is not possible, None is returned.
+
+    Parameters
+    ==========
+
+    left : Gate tuple
+        The left circuit of a gate rule expression.
+    right : Gate tuple
+        The right circuit of a gate rule expression.
+
+    Examples
+    ========
+
+    Generate a new gate rule using a RL operation:
+
+    >>> from sympy.physics.quantum.identitysearch import rl_op
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> rl_op((x,), (y, z))
+    ((Y(0), X(0)), (Z(0),))
+
+    >>> rl_op((x, y), (z,))
+    ((Z(0), X(0), Y(0)), ())
+    """
+
+    if (len(right) > 0):
+        rl_gate = right[0]
+        rl_gate_is_unitary = is_scalar_matrix(
+            (Dagger(rl_gate), rl_gate), _get_min_qubits(rl_gate), True)
+
+    if (len(right) > 0 and rl_gate_is_unitary):
+        # Get the new right side w/o the leftmost gate
+        new_right = right[1:len(right)]
+        # Add the leftmost gate to the left position on the left side
+        new_left = (Dagger(rl_gate),) + left
+        # Return the new gate rule
+        return (new_left, new_right)
+
+    return None
+
+
+def rr_op(left, right):
+    """Perform a RR operation.
+
+    A RR operation multiplies both left and right circuits
+    with the dagger of the right circuit's rightmost gate, and
+    the dagger is multiplied on the right side of both circuits.
+
+    If a RR is possible, it returns the new gate rule as a
+    2-tuple (LHS, RHS), where LHS is the left circuit and
+    and RHS is the right circuit of the new rule.
+    If a RR is not possible, None is returned.
+
+    Parameters
+    ==========
+
+    left : Gate tuple
+        The left circuit of a gate rule expression.
+    right : Gate tuple
+        The right circuit of a gate rule expression.
+
+    Examples
+    ========
+
+    Generate a new gate rule using a RR operation:
+
+    >>> from sympy.physics.quantum.identitysearch import rr_op
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> rr_op((x, y), (z,))
+    ((X(0), Y(0), Z(0)), ())
+
+    >>> rr_op((x,), (y, z))
+    ((X(0), Z(0)), (Y(0),))
+    """
+
+    if (len(right) > 0):
+        rr_gate = right[len(right) - 1]
+        rr_gate_is_unitary = is_scalar_matrix(
+            (Dagger(rr_gate), rr_gate), _get_min_qubits(rr_gate), True)
+
+    if (len(right) > 0 and rr_gate_is_unitary):
+        # Get the new right side w/o the rightmost gate
+        new_right = right[0:len(right) - 1]
+        # Add the rightmost gate to the right position on the right side
+        new_left = left + (Dagger(rr_gate),)
+        # Return the new gate rule
+        return (new_left, new_right)
+
+    return None
+
+
+def generate_gate_rules(gate_seq, return_as_muls=False):
+    """Returns a set of gate rules.  Each gate rules is represented
+    as a 2-tuple of tuples or Muls.  An empty tuple represents an arbitrary
+    scalar value.
+
+    This function uses the four operations (LL, LR, RL, RR)
+    to generate the gate rules.
+
+    A gate rule is an expression such as ABC = D or AB = CD, where
+    A, B, C, and D are gates.  Each value on either side of the
+    equal sign represents a circuit.  The four operations allow
+    one to find a set of equivalent circuits from a gate identity.
+    The letters denoting the operation tell the user what
+    activities to perform on each expression.  The first letter
+    indicates which side of the equal sign to focus on.  The
+    second letter indicates which gate to focus on given the
+    side.  Once this information is determined, the inverse
+    of the gate is multiplied on both circuits to create a new
+    gate rule.
+
+    For example, given the identity, ABCD = 1, a LL operation
+    means look at the left value and multiply both left sides by the
+    inverse of the leftmost gate A.  If A is Hermitian, the inverse
+    of A is still A.  The resulting new rule is BCD = A.
+
+    The following is a summary of the four operations.  Assume
+    that in the examples, all gates are Hermitian.
+
+        LL : left circuit, left multiply
+             ABCD = E -> AABCD = AE -> BCD = AE
+        LR : left circuit, right multiply
+             ABCD = E -> ABCDD = ED -> ABC = ED
+        RL : right circuit, left multiply
+             ABC = ED -> EABC = EED -> EABC = D
+        RR : right circuit, right multiply
+             AB = CD -> ABD = CDD -> ABD = C
+
+    The number of gate rules generated is n*(n+1), where n
+    is the number of gates in the sequence (unproven).
+
+    Parameters
+    ==========
+
+    gate_seq : Gate tuple, Mul, or Number
+        A variable length tuple or Mul of Gates whose product is equal to
+        a scalar matrix
+    return_as_muls : bool
+        True to return a set of Muls; False to return a set of tuples
+
+    Examples
+    ========
+
+    Find the gate rules of the current circuit using tuples:
+
+    >>> from sympy.physics.quantum.identitysearch import generate_gate_rules
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> generate_gate_rules((x, x))
+    {((X(0),), (X(0),)), ((X(0), X(0)), ())}
+
+    >>> generate_gate_rules((x, y, z))
+    {((), (X(0), Z(0), Y(0))), ((), (Y(0), X(0), Z(0))),
+     ((), (Z(0), Y(0), X(0))), ((X(0),), (Z(0), Y(0))),
+     ((Y(0),), (X(0), Z(0))), ((Z(0),), (Y(0), X(0))),
+     ((X(0), Y(0)), (Z(0),)), ((Y(0), Z(0)), (X(0),)),
+     ((Z(0), X(0)), (Y(0),)), ((X(0), Y(0), Z(0)), ()),
+     ((Y(0), Z(0), X(0)), ()), ((Z(0), X(0), Y(0)), ())}
+
+    Find the gate rules of the current circuit using Muls:
+
+    >>> generate_gate_rules(x*x, return_as_muls=True)
+    {(1, 1)}
+
+    >>> generate_gate_rules(x*y*z, return_as_muls=True)
+    {(1, X(0)*Z(0)*Y(0)), (1, Y(0)*X(0)*Z(0)),
+     (1, Z(0)*Y(0)*X(0)), (X(0)*Y(0), Z(0)),
+     (Y(0)*Z(0), X(0)), (Z(0)*X(0), Y(0)),
+     (X(0)*Y(0)*Z(0), 1), (Y(0)*Z(0)*X(0), 1),
+     (Z(0)*X(0)*Y(0), 1), (X(0), Z(0)*Y(0)),
+     (Y(0), X(0)*Z(0)), (Z(0), Y(0)*X(0))}
+    """
+
+    if isinstance(gate_seq, Number):
+        if return_as_muls:
+            return {(S.One, S.One)}
+        else:
+            return {((), ())}
+
+    elif isinstance(gate_seq, Mul):
+        gate_seq = gate_seq.args
+
+    # Each item in queue is a 3-tuple:
+    #     i)   first item is the left side of an equality
+    #    ii)   second item is the right side of an equality
+    #   iii)   third item is the number of operations performed
+    # The argument, gate_seq, will start on the left side, and
+    # the right side will be empty, implying the presence of an
+    # identity.
+    queue = deque()
+    # A set of gate rules
+    rules = set()
+    # Maximum number of operations to perform
+    max_ops = len(gate_seq)
+
+    def process_new_rule(new_rule, ops):
+        if new_rule is not None:
+            new_left, new_right = new_rule
+
+            if new_rule not in rules and (new_right, new_left) not in rules:
+                rules.add(new_rule)
+            # If haven't reached the max limit on operations
+            if ops + 1 < max_ops:
+                queue.append(new_rule + (ops + 1,))
+
+    queue.append((gate_seq, (), 0))
+    rules.add((gate_seq, ()))
+
+    while len(queue) > 0:
+        left, right, ops = queue.popleft()
+
+        # Do a LL
+        new_rule = ll_op(left, right)
+        process_new_rule(new_rule, ops)
+        # Do a LR
+        new_rule = lr_op(left, right)
+        process_new_rule(new_rule, ops)
+        # Do a RL
+        new_rule = rl_op(left, right)
+        process_new_rule(new_rule, ops)
+        # Do a RR
+        new_rule = rr_op(left, right)
+        process_new_rule(new_rule, ops)
+
+    if return_as_muls:
+        # Convert each rule as tuples into a rule as muls
+        mul_rules = set()
+        for rule in rules:
+            left, right = rule
+            mul_rules.add((Mul(*left), Mul(*right)))
+
+        rules = mul_rules
+
+    return rules
+
+
+def generate_equivalent_ids(gate_seq, return_as_muls=False):
+    """Returns a set of equivalent gate identities.
+
+    A gate identity is a quantum circuit such that the product
+    of the gates in the circuit is equal to a scalar value.
+    For example, XYZ = i, where X, Y, Z are the Pauli gates and
+    i is the imaginary value, is considered a gate identity.
+
+    This function uses the four operations (LL, LR, RL, RR)
+    to generate the gate rules and, subsequently, to locate equivalent
+    gate identities.
+
+    Note that all equivalent identities are reachable in n operations
+    from the starting gate identity, where n is the number of gates
+    in the sequence.
+
+    The max number of gate identities is 2n, where n is the number
+    of gates in the sequence (unproven).
+
+    Parameters
+    ==========
+
+    gate_seq : Gate tuple, Mul, or Number
+        A variable length tuple or Mul of Gates whose product is equal to
+        a scalar matrix.
+    return_as_muls: bool
+        True to return as Muls; False to return as tuples
+
+    Examples
+    ========
+
+    Find equivalent gate identities from the current circuit with tuples:
+
+    >>> from sympy.physics.quantum.identitysearch import generate_equivalent_ids
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> generate_equivalent_ids((x, x))
+    {(X(0), X(0))}
+
+    >>> generate_equivalent_ids((x, y, z))
+    {(X(0), Y(0), Z(0)), (X(0), Z(0), Y(0)), (Y(0), X(0), Z(0)),
+     (Y(0), Z(0), X(0)), (Z(0), X(0), Y(0)), (Z(0), Y(0), X(0))}
+
+    Find equivalent gate identities from the current circuit with Muls:
+
+    >>> generate_equivalent_ids(x*x, return_as_muls=True)
+    {1}
+
+    >>> generate_equivalent_ids(x*y*z, return_as_muls=True)
+    {X(0)*Y(0)*Z(0), X(0)*Z(0)*Y(0), Y(0)*X(0)*Z(0),
+     Y(0)*Z(0)*X(0), Z(0)*X(0)*Y(0), Z(0)*Y(0)*X(0)}
+    """
+
+    if isinstance(gate_seq, Number):
+        return {S.One}
+    elif isinstance(gate_seq, Mul):
+        gate_seq = gate_seq.args
+
+    # Filter through the gate rules and keep the rules
+    # with an empty tuple either on the left or right side
+
+    # A set of equivalent gate identities
+    eq_ids = set()
+
+    gate_rules = generate_gate_rules(gate_seq)
+    for rule in gate_rules:
+        l, r = rule
+        if l == ():
+            eq_ids.add(r)
+        elif r == ():
+            eq_ids.add(l)
+
+    if return_as_muls:
+        convert_to_mul = lambda id_seq: Mul(*id_seq)
+        eq_ids = set(map(convert_to_mul, eq_ids))
+
+    return eq_ids
+
+
+class GateIdentity(Basic):
+    """Wrapper class for circuits that reduce to a scalar value.
+
+    A gate identity is a quantum circuit such that the product
+    of the gates in the circuit is equal to a scalar value.
+    For example, XYZ = i, where X, Y, Z are the Pauli gates and
+    i is the imaginary value, is considered a gate identity.
+
+    Parameters
+    ==========
+
+    args : Gate tuple
+        A variable length tuple of Gates that form an identity.
+
+    Examples
+    ========
+
+    Create a GateIdentity and look at its attributes:
+
+    >>> from sympy.physics.quantum.identitysearch import GateIdentity
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> an_identity = GateIdentity(x, y, z)
+    >>> an_identity.circuit
+    X(0)*Y(0)*Z(0)
+
+    >>> an_identity.equivalent_ids
+    {(X(0), Y(0), Z(0)), (X(0), Z(0), Y(0)), (Y(0), X(0), Z(0)),
+     (Y(0), Z(0), X(0)), (Z(0), X(0), Y(0)), (Z(0), Y(0), X(0))}
+    """
+
+    def __new__(cls, *args):
+        # args should be a tuple - a variable length argument list
+        obj = Basic.__new__(cls, *args)
+        obj._circuit = Mul(*args)
+        obj._rules = generate_gate_rules(args)
+        obj._eq_ids = generate_equivalent_ids(args)
+
+        return obj
+
+    @property
+    def circuit(self):
+        return self._circuit
+
+    @property
+    def gate_rules(self):
+        return self._rules
+
+    @property
+    def equivalent_ids(self):
+        return self._eq_ids
+
+    @property
+    def sequence(self):
+        return self.args
+
+    def __str__(self):
+        """Returns the string of gates in a tuple."""
+        return str(self.circuit)
+
+
+def is_degenerate(identity_set, gate_identity):
+    """Checks if a gate identity is a permutation of another identity.
+
+    Parameters
+    ==========
+
+    identity_set : set
+        A Python set with GateIdentity objects.
+    gate_identity : GateIdentity
+        The GateIdentity to check for existence in the set.
+
+    Examples
+    ========
+
+    Check if the identity is a permutation of another identity:
+
+    >>> from sympy.physics.quantum.identitysearch import (
+    ...     GateIdentity, is_degenerate)
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> an_identity = GateIdentity(x, y, z)
+    >>> id_set = {an_identity}
+    >>> another_id = (y, z, x)
+    >>> is_degenerate(id_set, another_id)
+    True
+
+    >>> another_id = (x, x)
+    >>> is_degenerate(id_set, another_id)
+    False
+    """
+
+    # For now, just iteratively go through the set and check if the current
+    # gate_identity is a permutation of an identity in the set
+    for an_id in identity_set:
+        if (gate_identity in an_id.equivalent_ids):
+            return True
+    return False
+
+
+def is_reducible(circuit, nqubits, begin, end):
+    """Determines if a circuit is reducible by checking
+    if its subcircuits are scalar values.
+
+    Parameters
+    ==========
+
+    circuit : Gate tuple
+        A tuple of Gates representing a circuit.  The circuit to check
+        if a gate identity is contained in a subcircuit.
+    nqubits : int
+        The number of qubits the circuit operates on.
+    begin : int
+        The leftmost gate in the circuit to include in a subcircuit.
+    end : int
+        The rightmost gate in the circuit to include in a subcircuit.
+
+    Examples
+    ========
+
+    Check if the circuit can be reduced:
+
+    >>> from sympy.physics.quantum.identitysearch import is_reducible
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> is_reducible((x, y, z), 1, 0, 3)
+    True
+
+    Check if an interval in the circuit can be reduced:
+
+    >>> is_reducible((x, y, z), 1, 1, 3)
+    False
+
+    >>> is_reducible((x, y, y), 1, 1, 3)
+    True
+    """
+
+    current_circuit = ()
+    # Start from the gate at "end" and go down to almost the gate at "begin"
+    for ndx in reversed(range(begin, end)):
+        next_gate = circuit[ndx]
+        current_circuit = (next_gate,) + current_circuit
+
+        # If a circuit as a matrix is equivalent to a scalar value
+        if (is_scalar_matrix(current_circuit, nqubits, False)):
+            return True
+
+    return False
+
+
+def bfs_identity_search(gate_list, nqubits, max_depth=None,
+       identity_only=False):
+    """Constructs a set of gate identities from the list of possible gates.
+
+    Performs a breadth first search over the space of gate identities.
+    This allows the finding of the shortest gate identities first.
+
+    Parameters
+    ==========
+
+    gate_list : list, Gate
+        A list of Gates from which to search for gate identities.
+    nqubits : int
+        The number of qubits the quantum circuit operates on.
+    max_depth : int
+        The longest quantum circuit to construct from gate_list.
+    identity_only : bool
+        True to search for gate identities that reduce to identity;
+        False to search for gate identities that reduce to a scalar.
+
+    Examples
+    ========
+
+    Find a list of gate identities:
+
+    >>> from sympy.physics.quantum.identitysearch import bfs_identity_search
+    >>> from sympy.physics.quantum.gate import X, Y, Z
+    >>> x = X(0); y = Y(0); z = Z(0)
+    >>> bfs_identity_search([x], 1, max_depth=2)
+    {GateIdentity(X(0), X(0))}
+
+    >>> bfs_identity_search([x, y, z], 1)
+    {GateIdentity(X(0), X(0)), GateIdentity(Y(0), Y(0)),
+     GateIdentity(Z(0), Z(0)), GateIdentity(X(0), Y(0), Z(0))}
+
+    Find a list of identities that only equal to 1:
+
+    >>> bfs_identity_search([x, y, z], 1, identity_only=True)
+    {GateIdentity(X(0), X(0)), GateIdentity(Y(0), Y(0)),
+     GateIdentity(Z(0), Z(0))}
+    """
+
+    if max_depth is None or max_depth <= 0:
+        max_depth = len(gate_list)
+
+    id_only = identity_only
+
+    # Start with an empty sequence (implicitly contains an IdentityGate)
+    queue = deque([()])
+
+    # Create an empty set of gate identities
+    ids = set()
+
+    # Begin searching for gate identities in given space.
+    while (len(queue) > 0):
+        current_circuit = queue.popleft()
+
+        for next_gate in gate_list:
+            new_circuit = current_circuit + (next_gate,)
+
+            # Determines if a (strict) subcircuit is a scalar matrix
+            circuit_reducible = is_reducible(new_circuit, nqubits,
+                                             1, len(new_circuit))
+
+            # In many cases when the matrix is a scalar value,
+            # the evaluated matrix will actually be an integer
+            if (is_scalar_matrix(new_circuit, nqubits, id_only) and
+                not is_degenerate(ids, new_circuit) and
+                    not circuit_reducible):
+                ids.add(GateIdentity(*new_circuit))
+
+            elif (len(new_circuit) < max_depth and
+                  not circuit_reducible):
+                queue.append(new_circuit)
+
+    return ids
+
+
+def random_identity_search(gate_list, numgates, nqubits):
+    """Randomly selects numgates from gate_list and checks if it is
+    a gate identity.
+
+    If the circuit is a gate identity, the circuit is returned;
+    Otherwise, None is returned.
+    """
+
+    gate_size = len(gate_list)
+    circuit = ()
+
+    for i in range(numgates):
+        next_gate = gate_list[randint(0, gate_size - 1)]
+        circuit = circuit + (next_gate,)
+
+    is_scalar = is_scalar_matrix(circuit, nqubits, False)
+
+    return circuit if is_scalar else None

venv/lib/python3.10/site-packages/sympy/physics/quantum/innerproduct.py

@@ -0,0 +1,137 @@
+"""Symbolic inner product."""
+
+from sympy.core.expr import Expr
+from sympy.functions.elementary.complexes import conjugate
+from sympy.printing.pretty.stringpict import prettyForm
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.state import KetBase, BraBase
+
+__all__ = [
+    'InnerProduct'
+]
+
+
+# InnerProduct is not an QExpr because it is really just a regular commutative
+# number. We have gone back and forth about this, but we gain a lot by having
+# it subclass Expr. The main challenges were getting Dagger to work
+# (we use _eval_conjugate) and represent (we can use atoms and subs). Having
+# it be an Expr, mean that there are no commutative QExpr subclasses,
+# which simplifies the design of everything.
+
+class InnerProduct(Expr):
+    """An unevaluated inner product between a Bra and a Ket [1].
+
+    Parameters
+    ==========
+
+    bra : BraBase or subclass
+        The bra on the left side of the inner product.
+    ket : KetBase or subclass
+        The ket on the right side of the inner product.
+
+    Examples
+    ========
+
+    Create an InnerProduct and check its properties:
+
+        >>> from sympy.physics.quantum import Bra, Ket
+        >>> b = Bra('b')
+        >>> k = Ket('k')
+        >>> ip = b*k
+        >>> ip
+        <b|k>
+        >>> ip.bra
+        <b|
+        >>> ip.ket
+        |k>
+
+    In simple products of kets and bras inner products will be automatically
+    identified and created::
+
+        >>> b*k
+        <b|k>
+
+    But in more complex expressions, there is ambiguity in whether inner or
+    outer products should be created::
+
+        >>> k*b*k*b
+        |k><b|*|k>*<b|
+
+    A user can force the creation of a inner products in a complex expression
+    by using parentheses to group the bra and ket::
+
+        >>> k*(b*k)*b
+        <b|k>*|k>*<b|
+
+    Notice how the inner product <b|k> moved to the left of the expression
+    because inner products are commutative complex numbers.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Inner_product
+    """
+    is_complex = True
+
+    def __new__(cls, bra, ket):
+        if not isinstance(ket, KetBase):
+            raise TypeError('KetBase subclass expected, got: %r' % ket)
+        if not isinstance(bra, BraBase):
+            raise TypeError('BraBase subclass expected, got: %r' % ket)
+        obj = Expr.__new__(cls, bra, ket)
+        return obj
+
+    @property
+    def bra(self):
+        return self.args[0]
+
+    @property
+    def ket(self):
+        return self.args[1]
+
+    def _eval_conjugate(self):
+        return InnerProduct(Dagger(self.ket), Dagger(self.bra))
+
+    def _sympyrepr(self, printer, *args):
+        return '%s(%s,%s)' % (self.__class__.__name__,
+            printer._print(self.bra, *args), printer._print(self.ket, *args))
+
+    def _sympystr(self, printer, *args):
+        sbra = printer._print(self.bra)
+        sket = printer._print(self.ket)
+        return '%s|%s' % (sbra[:-1], sket[1:])
+
+    def _pretty(self, printer, *args):
+        # Print state contents
+        bra = self.bra._print_contents_pretty(printer, *args)
+        ket = self.ket._print_contents_pretty(printer, *args)
+        # Print brackets
+        height = max(bra.height(), ket.height())
+        use_unicode = printer._use_unicode
+        lbracket, _ = self.bra._pretty_brackets(height, use_unicode)
+        cbracket, rbracket = self.ket._pretty_brackets(height, use_unicode)
+        # Build innerproduct
+        pform = prettyForm(*bra.left(lbracket))
+        pform = prettyForm(*pform.right(cbracket))
+        pform = prettyForm(*pform.right(ket))
+        pform = prettyForm(*pform.right(rbracket))
+        return pform
+
+    def _latex(self, printer, *args):
+        bra_label = self.bra._print_contents_latex(printer, *args)
+        ket = printer._print(self.ket, *args)
+        return r'\left\langle %s \right. %s' % (bra_label, ket)
+
+    def doit(self, **hints):
+        try:
+            r = self.ket._eval_innerproduct(self.bra, **hints)
+        except NotImplementedError:
+            try:
+                r = conjugate(
+                    self.bra.dual._eval_innerproduct(self.ket.dual, **hints)
+                )
+            except NotImplementedError:
+                r = None
+        if r is not None:
+            return r
+        return self

venv/lib/python3.10/site-packages/sympy/physics/quantum/matrixcache.py

@@ -0,0 +1,103 @@
+"""A cache for storing small matrices in multiple formats."""
+
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.power import Pow
+from sympy.functions.elementary.exponential import exp
+from sympy.matrices.dense import Matrix
+
+from sympy.physics.quantum.matrixutils import (
+    to_sympy, to_numpy, to_scipy_sparse
+)
+
+
+class MatrixCache:
+    """A cache for small matrices in different formats.
+
+    This class takes small matrices in the standard ``sympy.Matrix`` format,
+    and then converts these to both ``numpy.matrix`` and
+    ``scipy.sparse.csr_matrix`` matrices. These matrices are then stored for
+    future recovery.
+    """
+
+    def __init__(self, dtype='complex'):
+        self._cache = {}
+        self.dtype = dtype
+
+    def cache_matrix(self, name, m):
+        """Cache a matrix by its name.
+
+        Parameters
+        ----------
+        name : str
+            A descriptive name for the matrix, like "identity2".
+        m : list of lists
+            The raw matrix data as a SymPy Matrix.
+        """
+        try:
+            self._sympy_matrix(name, m)
+        except ImportError:
+            pass
+        try:
+            self._numpy_matrix(name, m)
+        except ImportError:
+            pass
+        try:
+            self._scipy_sparse_matrix(name, m)
+        except ImportError:
+            pass
+
+    def get_matrix(self, name, format):
+        """Get a cached matrix by name and format.
+
+        Parameters
+        ----------
+        name : str
+            A descriptive name for the matrix, like "identity2".
+        format : str
+            The format desired ('sympy', 'numpy', 'scipy.sparse')
+        """
+        m = self._cache.get((name, format))
+        if m is not None:
+            return m
+        raise NotImplementedError(
+            'Matrix with name %s and format %s is not available.' %
+            (name, format)
+        )
+
+    def _store_matrix(self, name, format, m):
+        self._cache[(name, format)] = m
+
+    def _sympy_matrix(self, name, m):
+        self._store_matrix(name, 'sympy', to_sympy(m))
+
+    def _numpy_matrix(self, name, m):
+        m = to_numpy(m, dtype=self.dtype)
+        self._store_matrix(name, 'numpy', m)
+
+    def _scipy_sparse_matrix(self, name, m):
+        # TODO: explore different sparse formats. But sparse.kron will use
+        # coo in most cases, so we use that here.
+        m = to_scipy_sparse(m, dtype=self.dtype)
+        self._store_matrix(name, 'scipy.sparse', m)
+
+
+sqrt2_inv = Pow(2, Rational(-1, 2), evaluate=False)
+
+# Save the common matrices that we will need
+matrix_cache = MatrixCache()
+matrix_cache.cache_matrix('eye2', Matrix([[1, 0], [0, 1]]))
+matrix_cache.cache_matrix('op11', Matrix([[0, 0], [0, 1]]))  # |1><1|
+matrix_cache.cache_matrix('op00', Matrix([[1, 0], [0, 0]]))  # |0><0|
+matrix_cache.cache_matrix('op10', Matrix([[0, 0], [1, 0]]))  # |1><0|
+matrix_cache.cache_matrix('op01', Matrix([[0, 1], [0, 0]]))  # |0><1|
+matrix_cache.cache_matrix('X', Matrix([[0, 1], [1, 0]]))
+matrix_cache.cache_matrix('Y', Matrix([[0, -I], [I, 0]]))
+matrix_cache.cache_matrix('Z', Matrix([[1, 0], [0, -1]]))
+matrix_cache.cache_matrix('S', Matrix([[1, 0], [0, I]]))
+matrix_cache.cache_matrix('T', Matrix([[1, 0], [0, exp(I*pi/4)]]))
+matrix_cache.cache_matrix('H', sqrt2_inv*Matrix([[1, 1], [1, -1]]))
+matrix_cache.cache_matrix('Hsqrt2', Matrix([[1, 1], [1, -1]]))
+matrix_cache.cache_matrix(
+    'SWAP', Matrix([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]))
+matrix_cache.cache_matrix('ZX', sqrt2_inv*Matrix([[1, 1], [1, -1]]))
+matrix_cache.cache_matrix('ZY', Matrix([[I, 0], [0, -I]]))

venv/lib/python3.10/site-packages/sympy/physics/quantum/matrixutils.py

@@ -0,0 +1,272 @@
+"""Utilities to deal with sympy.Matrix, numpy and scipy.sparse."""
+
+from sympy.core.expr import Expr
+from sympy.core.numbers import I
+from sympy.core.singleton import S
+from sympy.matrices.matrices import MatrixBase
+from sympy.matrices import eye, zeros
+from sympy.external import import_module
+
+__all__ = [
+    'numpy_ndarray',
+    'scipy_sparse_matrix',
+    'sympy_to_numpy',
+    'sympy_to_scipy_sparse',
+    'numpy_to_sympy',
+    'scipy_sparse_to_sympy',
+    'flatten_scalar',
+    'matrix_dagger',
+    'to_sympy',
+    'to_numpy',
+    'to_scipy_sparse',
+    'matrix_tensor_product',
+    'matrix_zeros'
+]
+
+# Conditionally define the base classes for numpy and scipy.sparse arrays
+# for use in isinstance tests.
+
+np = import_module('numpy')
+if not np:
+    class numpy_ndarray:
+        pass
+else:
+    numpy_ndarray = np.ndarray  # type: ignore
+
+scipy = import_module('scipy', import_kwargs={'fromlist': ['sparse']})
+if not scipy:
+    class scipy_sparse_matrix:
+        pass
+    sparse = None
+else:
+    sparse = scipy.sparse
+    scipy_sparse_matrix = sparse.spmatrix # type: ignore
+
+
+def sympy_to_numpy(m, **options):
+    """Convert a SymPy Matrix/complex number to a numpy matrix or scalar."""
+    if not np:
+        raise ImportError
+    dtype = options.get('dtype', 'complex')
+    if isinstance(m, MatrixBase):
+        return np.array(m.tolist(), dtype=dtype)
+    elif isinstance(m, Expr):
+        if m.is_Number or m.is_NumberSymbol or m == I:
+            return complex(m)
+    raise TypeError('Expected MatrixBase or complex scalar, got: %r' % m)
+
+
+def sympy_to_scipy_sparse(m, **options):
+    """Convert a SymPy Matrix/complex number to a numpy matrix or scalar."""
+    if not np or not sparse:
+        raise ImportError
+    dtype = options.get('dtype', 'complex')
+    if isinstance(m, MatrixBase):
+        return sparse.csr_matrix(np.array(m.tolist(), dtype=dtype))
+    elif isinstance(m, Expr):
+        if m.is_Number or m.is_NumberSymbol or m == I:
+            return complex(m)
+    raise TypeError('Expected MatrixBase or complex scalar, got: %r' % m)
+
+
+def scipy_sparse_to_sympy(m, **options):
+    """Convert a scipy.sparse matrix to a SymPy matrix."""
+    return MatrixBase(m.todense())
+
+
+def numpy_to_sympy(m, **options):
+    """Convert a numpy matrix to a SymPy matrix."""
+    return MatrixBase(m)
+
+
+def to_sympy(m, **options):
+    """Convert a numpy/scipy.sparse matrix to a SymPy matrix."""
+    if isinstance(m, MatrixBase):
+        return m
+    elif isinstance(m, numpy_ndarray):
+        return numpy_to_sympy(m)
+    elif isinstance(m, scipy_sparse_matrix):
+        return scipy_sparse_to_sympy(m)
+    elif isinstance(m, Expr):
+        return m
+    raise TypeError('Expected sympy/numpy/scipy.sparse matrix, got: %r' % m)
+
+
+def to_numpy(m, **options):
+    """Convert a sympy/scipy.sparse matrix to a numpy matrix."""
+    dtype = options.get('dtype', 'complex')
+    if isinstance(m, (MatrixBase, Expr)):
+        return sympy_to_numpy(m, dtype=dtype)
+    elif isinstance(m, numpy_ndarray):
+        return m
+    elif isinstance(m, scipy_sparse_matrix):
+        return m.todense()
+    raise TypeError('Expected sympy/numpy/scipy.sparse matrix, got: %r' % m)
+
+
+def to_scipy_sparse(m, **options):
+    """Convert a sympy/numpy matrix to a scipy.sparse matrix."""
+    dtype = options.get('dtype', 'complex')
+    if isinstance(m, (MatrixBase, Expr)):
+        return sympy_to_scipy_sparse(m, dtype=dtype)
+    elif isinstance(m, numpy_ndarray):
+        if not sparse:
+            raise ImportError
+        return sparse.csr_matrix(m)
+    elif isinstance(m, scipy_sparse_matrix):
+        return m
+    raise TypeError('Expected sympy/numpy/scipy.sparse matrix, got: %r' % m)
+
+
+def flatten_scalar(e):
+    """Flatten a 1x1 matrix to a scalar, return larger matrices unchanged."""
+    if isinstance(e, MatrixBase):
+        if e.shape == (1, 1):
+            e = e[0]
+    if isinstance(e, (numpy_ndarray, scipy_sparse_matrix)):
+        if e.shape == (1, 1):
+            e = complex(e[0, 0])
+    return e
+
+
+def matrix_dagger(e):
+    """Return the dagger of a sympy/numpy/scipy.sparse matrix."""
+    if isinstance(e, MatrixBase):
+        return e.H
+    elif isinstance(e, (numpy_ndarray, scipy_sparse_matrix)):
+        return e.conjugate().transpose()
+    raise TypeError('Expected sympy/numpy/scipy.sparse matrix, got: %r' % e)
+
+
+# TODO: Move this into sympy.matricies.
+def _sympy_tensor_product(*matrices):
+    """Compute the kronecker product of a sequence of SymPy Matrices.
+    """
+    from sympy.matrices.expressions.kronecker import matrix_kronecker_product
+
+    return matrix_kronecker_product(*matrices)
+
+
+def _numpy_tensor_product(*product):
+    """numpy version of tensor product of multiple arguments."""
+    if not np:
+        raise ImportError
+    answer = product[0]
+    for item in product[1:]:
+        answer = np.kron(answer, item)
+    return answer
+
+
+def _scipy_sparse_tensor_product(*product):
+    """scipy.sparse version of tensor product of multiple arguments."""
+    if not sparse:
+        raise ImportError
+    answer = product[0]
+    for item in product[1:]:
+        answer = sparse.kron(answer, item)
+    # The final matrices will just be multiplied, so csr is a good final
+    # sparse format.
+    return sparse.csr_matrix(answer)
+
+
+def matrix_tensor_product(*product):
+    """Compute the matrix tensor product of sympy/numpy/scipy.sparse matrices."""
+    if isinstance(product[0], MatrixBase):
+        return _sympy_tensor_product(*product)
+    elif isinstance(product[0], numpy_ndarray):
+        return _numpy_tensor_product(*product)
+    elif isinstance(product[0], scipy_sparse_matrix):
+        return _scipy_sparse_tensor_product(*product)
+
+
+def _numpy_eye(n):
+    """numpy version of complex eye."""
+    if not np:
+        raise ImportError
+    return np.array(np.eye(n, dtype='complex'))
+
+
+def _scipy_sparse_eye(n):
+    """scipy.sparse version of complex eye."""
+    if not sparse:
+        raise ImportError
+    return sparse.eye(n, n, dtype='complex')
+
+
+def matrix_eye(n, **options):
+    """Get the version of eye and tensor_product for a given format."""
+    format = options.get('format', 'sympy')
+    if format == 'sympy':
+        return eye(n)
+    elif format == 'numpy':
+        return _numpy_eye(n)
+    elif format == 'scipy.sparse':
+        return _scipy_sparse_eye(n)
+    raise NotImplementedError('Invalid format: %r' % format)
+
+
+def _numpy_zeros(m, n, **options):
+    """numpy version of zeros."""
+    dtype = options.get('dtype', 'float64')
+    if not np:
+        raise ImportError
+    return np.zeros((m, n), dtype=dtype)
+
+
+def _scipy_sparse_zeros(m, n, **options):
+    """scipy.sparse version of zeros."""
+    spmatrix = options.get('spmatrix', 'csr')
+    dtype = options.get('dtype', 'float64')
+    if not sparse:
+        raise ImportError
+    if spmatrix == 'lil':
+        return sparse.lil_matrix((m, n), dtype=dtype)
+    elif spmatrix == 'csr':
+        return sparse.csr_matrix((m, n), dtype=dtype)
+
+
+def matrix_zeros(m, n, **options):
+    """"Get a zeros matrix for a given format."""
+    format = options.get('format', 'sympy')
+    if format == 'sympy':
+        return zeros(m, n)
+    elif format == 'numpy':
+        return _numpy_zeros(m, n, **options)
+    elif format == 'scipy.sparse':
+        return _scipy_sparse_zeros(m, n, **options)
+    raise NotImplementedError('Invaild format: %r' % format)
+
+
+def _numpy_matrix_to_zero(e):
+    """Convert a numpy zero matrix to the zero scalar."""
+    if not np:
+        raise ImportError
+    test = np.zeros_like(e)
+    if np.allclose(e, test):
+        return 0.0
+    else:
+        return e
+
+
+def _scipy_sparse_matrix_to_zero(e):
+    """Convert a scipy.sparse zero matrix to the zero scalar."""
+    if not np:
+        raise ImportError
+    edense = e.todense()
+    test = np.zeros_like(edense)
+    if np.allclose(edense, test):
+        return 0.0
+    else:
+        return e
+
+
+def matrix_to_zero(e):
+    """Convert a zero matrix to the scalar zero."""
+    if isinstance(e, MatrixBase):
+        if zeros(*e.shape) == e:
+            e = S.Zero
+    elif isinstance(e, numpy_ndarray):
+        e = _numpy_matrix_to_zero(e)
+    elif isinstance(e, scipy_sparse_matrix):
+        e = _scipy_sparse_matrix_to_zero(e)
+    return e

venv/lib/python3.10/site-packages/sympy/physics/quantum/operator.py

@@ -0,0 +1,650 @@
+"""Quantum mechanical operators.
+
+TODO:
+
+* Fix early 0 in apply_operators.
+* Debug and test apply_operators.
+* Get cse working with classes in this file.
+* Doctests and documentation of special methods for InnerProduct, Commutator,
+  AntiCommutator, represent, apply_operators.
+"""
+
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.function import (Derivative, expand)
+from sympy.core.mul import Mul
+from sympy.core.numbers import oo
+from sympy.core.singleton import S
+from sympy.printing.pretty.stringpict import prettyForm
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.qexpr import QExpr, dispatch_method
+from sympy.matrices import eye
+
+__all__ = [
+    'Operator',
+    'HermitianOperator',
+    'UnitaryOperator',
+    'IdentityOperator',
+    'OuterProduct',
+    'DifferentialOperator'
+]
+
+#-----------------------------------------------------------------------------
+# Operators and outer products
+#-----------------------------------------------------------------------------
+
+
+class Operator(QExpr):
+    """Base class for non-commuting quantum operators.
+
+    An operator maps between quantum states [1]_. In quantum mechanics,
+    observables (including, but not limited to, measured physical values) are
+    represented as Hermitian operators [2]_.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        operator. For time-dependent operators, this will include the time.
+
+    Examples
+    ========
+
+    Create an operator and examine its attributes::
+
+        >>> from sympy.physics.quantum import Operator
+        >>> from sympy import I
+        >>> A = Operator('A')
+        >>> A
+        A
+        >>> A.hilbert_space
+        H
+        >>> A.label
+        (A,)
+        >>> A.is_commutative
+        False
+
+    Create another operator and do some arithmetic operations::
+
+        >>> B = Operator('B')
+        >>> C = 2*A*A + I*B
+        >>> C
+        2*A**2 + I*B
+
+    Operators do not commute::
+
+        >>> A.is_commutative
+        False
+        >>> B.is_commutative
+        False
+        >>> A*B == B*A
+        False
+
+    Polymonials of operators respect the commutation properties::
+
+        >>> e = (A+B)**3
+        >>> e.expand()
+        A*B*A + A*B**2 + A**2*B + A**3 + B*A*B + B*A**2 + B**2*A + B**3
+
+    Operator inverses are handle symbolically::
+
+        >>> A.inv()
+        A**(-1)
+        >>> A*A.inv()
+        1
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Operator_%28physics%29
+    .. [2] https://en.wikipedia.org/wiki/Observable
+    """
+
+    @classmethod
+    def default_args(self):
+        return ("O",)
+
+    #-------------------------------------------------------------------------
+    # Printing
+    #-------------------------------------------------------------------------
+
+    _label_separator = ','
+
+    def _print_operator_name(self, printer, *args):
+        return self.__class__.__name__
+
+    _print_operator_name_latex = _print_operator_name
+
+    def _print_operator_name_pretty(self, printer, *args):
+        return prettyForm(self.__class__.__name__)
+
+    def _print_contents(self, printer, *args):
+        if len(self.label) == 1:
+            return self._print_label(printer, *args)
+        else:
+            return '%s(%s)' % (
+                self._print_operator_name(printer, *args),
+                self._print_label(printer, *args)
+            )
+
+    def _print_contents_pretty(self, printer, *args):
+        if len(self.label) == 1:
+            return self._print_label_pretty(printer, *args)
+        else:
+            pform = self._print_operator_name_pretty(printer, *args)
+            label_pform = self._print_label_pretty(printer, *args)
+            label_pform = prettyForm(
+                *label_pform.parens(left='(', right=')')
+            )
+            pform = prettyForm(*pform.right(label_pform))
+            return pform
+
+    def _print_contents_latex(self, printer, *args):
+        if len(self.label) == 1:
+            return self._print_label_latex(printer, *args)
+        else:
+            return r'%s\left(%s\right)' % (
+                self._print_operator_name_latex(printer, *args),
+                self._print_label_latex(printer, *args)
+            )
+
+    #-------------------------------------------------------------------------
+    # _eval_* methods
+    #-------------------------------------------------------------------------
+
+    def _eval_commutator(self, other, **options):
+        """Evaluate [self, other] if known, return None if not known."""
+        return dispatch_method(self, '_eval_commutator', other, **options)
+
+    def _eval_anticommutator(self, other, **options):
+        """Evaluate [self, other] if known."""
+        return dispatch_method(self, '_eval_anticommutator', other, **options)
+
+    #-------------------------------------------------------------------------
+    # Operator application
+    #-------------------------------------------------------------------------
+
+    def _apply_operator(self, ket, **options):
+        return dispatch_method(self, '_apply_operator', ket, **options)
+
+    def matrix_element(self, *args):
+        raise NotImplementedError('matrix_elements is not defined')
+
+    def inverse(self):
+        return self._eval_inverse()
+
+    inv = inverse
+
+    def _eval_inverse(self):
+        return self**(-1)
+
+    def __mul__(self, other):
+
+        if isinstance(other, IdentityOperator):
+            return self
+
+        return Mul(self, other)
+
+
+class HermitianOperator(Operator):
+    """A Hermitian operator that satisfies H == Dagger(H).
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        operator. For time-dependent operators, this will include the time.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import Dagger, HermitianOperator
+    >>> H = HermitianOperator('H')
+    >>> Dagger(H)
+    H
+    """
+
+    is_hermitian = True
+
+    def _eval_inverse(self):
+        if isinstance(self, UnitaryOperator):
+            return self
+        else:
+            return Operator._eval_inverse(self)
+
+    def _eval_power(self, exp):
+        if isinstance(self, UnitaryOperator):
+            # so all eigenvalues of self are 1 or -1
+            if exp.is_even:
+                from sympy.core.singleton import S
+                return S.One # is identity, see Issue 24153.
+            elif exp.is_odd:
+                return self
+        # No simplification in all other cases
+        return Operator._eval_power(self, exp)
+
+
+class UnitaryOperator(Operator):
+    """A unitary operator that satisfies U*Dagger(U) == 1.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        operator. For time-dependent operators, this will include the time.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import Dagger, UnitaryOperator
+    >>> U = UnitaryOperator('U')
+    >>> U*Dagger(U)
+    1
+    """
+
+    def _eval_adjoint(self):
+        return self._eval_inverse()
+
+
+class IdentityOperator(Operator):
+    """An identity operator I that satisfies op * I == I * op == op for any
+    operator op.
+
+    Parameters
+    ==========
+
+    N : Integer
+        Optional parameter that specifies the dimension of the Hilbert space
+        of operator. This is used when generating a matrix representation.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import IdentityOperator
+    >>> IdentityOperator()
+    I
+    """
+    @property
+    def dimension(self):
+        return self.N
+
+    @classmethod
+    def default_args(self):
+        return (oo,)
+
+    def __init__(self, *args, **hints):
+        if not len(args) in (0, 1):
+            raise ValueError('0 or 1 parameters expected, got %s' % args)
+
+        self.N = args[0] if (len(args) == 1 and args[0]) else oo
+
+    def _eval_commutator(self, other, **hints):
+        return S.Zero
+
+    def _eval_anticommutator(self, other, **hints):
+        return 2 * other
+
+    def _eval_inverse(self):
+        return self
+
+    def _eval_adjoint(self):
+        return self
+
+    def _apply_operator(self, ket, **options):
+        return ket
+
+    def _apply_from_right_to(self, bra, **options):
+        return bra
+
+    def _eval_power(self, exp):
+        return self
+
+    def _print_contents(self, printer, *args):
+        return 'I'
+
+    def _print_contents_pretty(self, printer, *args):
+        return prettyForm('I')
+
+    def _print_contents_latex(self, printer, *args):
+        return r'{\mathcal{I}}'
+
+    def __mul__(self, other):
+
+        if isinstance(other, (Operator, Dagger)):
+            return other
+
+        return Mul(self, other)
+
+    def _represent_default_basis(self, **options):
+        if not self.N or self.N == oo:
+            raise NotImplementedError('Cannot represent infinite dimensional' +
+                                      ' identity operator as a matrix')
+
+        format = options.get('format', 'sympy')
+        if format != 'sympy':
+            raise NotImplementedError('Representation in format ' +
+                                      '%s not implemented.' % format)
+
+        return eye(self.N)
+
+
+class OuterProduct(Operator):
+    """An unevaluated outer product between a ket and bra.
+
+    This constructs an outer product between any subclass of ``KetBase`` and
+    ``BraBase`` as ``|a><b|``. An ``OuterProduct`` inherits from Operator as they act as
+    operators in quantum expressions.  For reference see [1]_.
+
+    Parameters
+    ==========
+
+    ket : KetBase
+        The ket on the left side of the outer product.
+    bar : BraBase
+        The bra on the right side of the outer product.
+
+    Examples
+    ========
+
+    Create a simple outer product by hand and take its dagger::
+
+        >>> from sympy.physics.quantum import Ket, Bra, OuterProduct, Dagger
+        >>> from sympy.physics.quantum import Operator
+
+        >>> k = Ket('k')
+        >>> b = Bra('b')
+        >>> op = OuterProduct(k, b)
+        >>> op
+        |k><b|
+        >>> op.hilbert_space
+        H
+        >>> op.ket
+        |k>
+        >>> op.bra
+        <b|
+        >>> Dagger(op)
+        |b><k|
+
+    In simple products of kets and bras outer products will be automatically
+    identified and created::
+
+        >>> k*b
+        |k><b|
+
+    But in more complex expressions, outer products are not automatically
+    created::
+
+        >>> A = Operator('A')
+        >>> A*k*b
+        A*|k>*<b|
+
+    A user can force the creation of an outer product in a complex expression
+    by using parentheses to group the ket and bra::
+
+        >>> A*(k*b)
+        A*|k><b|
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Outer_product
+    """
+    is_commutative = False
+
+    def __new__(cls, *args, **old_assumptions):
+        from sympy.physics.quantum.state import KetBase, BraBase
+
+        if len(args) != 2:
+            raise ValueError('2 parameters expected, got %d' % len(args))
+
+        ket_expr = expand(args[0])
+        bra_expr = expand(args[1])
+
+        if (isinstance(ket_expr, (KetBase, Mul)) and
+                isinstance(bra_expr, (BraBase, Mul))):
+            ket_c, kets = ket_expr.args_cnc()
+            bra_c, bras = bra_expr.args_cnc()
+
+            if len(kets) != 1 or not isinstance(kets[0], KetBase):
+                raise TypeError('KetBase subclass expected'
+                                ', got: %r' % Mul(*kets))
+
+            if len(bras) != 1 or not isinstance(bras[0], BraBase):
+                raise TypeError('BraBase subclass expected'
+                                ', got: %r' % Mul(*bras))
+
+            if not kets[0].dual_class() == bras[0].__class__:
+                raise TypeError(
+                    'ket and bra are not dual classes: %r, %r' %
+                    (kets[0].__class__, bras[0].__class__)
+                    )
+
+            # TODO: make sure the hilbert spaces of the bra and ket are
+            # compatible
+            obj = Expr.__new__(cls, *(kets[0], bras[0]), **old_assumptions)
+            obj.hilbert_space = kets[0].hilbert_space
+            return Mul(*(ket_c + bra_c)) * obj
+
+        op_terms = []
+        if isinstance(ket_expr, Add) and isinstance(bra_expr, Add):
+            for ket_term in ket_expr.args:
+                for bra_term in bra_expr.args:
+                    op_terms.append(OuterProduct(ket_term, bra_term,
+                                                 **old_assumptions))
+        elif isinstance(ket_expr, Add):
+            for ket_term in ket_expr.args:
+                op_terms.append(OuterProduct(ket_term, bra_expr,
+                                             **old_assumptions))
+        elif isinstance(bra_expr, Add):
+            for bra_term in bra_expr.args:
+                op_terms.append(OuterProduct(ket_expr, bra_term,
+                                             **old_assumptions))
+        else:
+            raise TypeError(
+                'Expected ket and bra expression, got: %r, %r' %
+                (ket_expr, bra_expr)
+                )
+
+        return Add(*op_terms)
+
+    @property
+    def ket(self):
+        """Return the ket on the left side of the outer product."""
+        return self.args[0]
+
+    @property
+    def bra(self):
+        """Return the bra on the right side of the outer product."""
+        return self.args[1]
+
+    def _eval_adjoint(self):
+        return OuterProduct(Dagger(self.bra), Dagger(self.ket))
+
+    def _sympystr(self, printer, *args):
+        return printer._print(self.ket) + printer._print(self.bra)
+
+    def _sympyrepr(self, printer, *args):
+        return '%s(%s,%s)' % (self.__class__.__name__,
+            printer._print(self.ket, *args), printer._print(self.bra, *args))
+
+    def _pretty(self, printer, *args):
+        pform = self.ket._pretty(printer, *args)
+        return prettyForm(*pform.right(self.bra._pretty(printer, *args)))
+
+    def _latex(self, printer, *args):
+        k = printer._print(self.ket, *args)
+        b = printer._print(self.bra, *args)
+        return k + b
+
+    def _represent(self, **options):
+        k = self.ket._represent(**options)
+        b = self.bra._represent(**options)
+        return k*b
+
+    def _eval_trace(self, **kwargs):
+        # TODO if operands are tensorproducts this may be will be handled
+        # differently.
+
+        return self.ket._eval_trace(self.bra, **kwargs)
+
+
+class DifferentialOperator(Operator):
+    """An operator for representing the differential operator, i.e. d/dx
+
+    It is initialized by passing two arguments. The first is an arbitrary
+    expression that involves a function, such as ``Derivative(f(x), x)``. The
+    second is the function (e.g. ``f(x)``) which we are to replace with the
+    ``Wavefunction`` that this ``DifferentialOperator`` is applied to.
+
+    Parameters
+    ==========
+
+    expr : Expr
+           The arbitrary expression which the appropriate Wavefunction is to be
+           substituted into
+
+    func : Expr
+           A function (e.g. f(x)) which is to be replaced with the appropriate
+           Wavefunction when this DifferentialOperator is applied
+
+    Examples
+    ========
+
+    You can define a completely arbitrary expression and specify where the
+    Wavefunction is to be substituted
+
+    >>> from sympy import Derivative, Function, Symbol
+    >>> from sympy.physics.quantum.operator import DifferentialOperator
+    >>> from sympy.physics.quantum.state import Wavefunction
+    >>> from sympy.physics.quantum.qapply import qapply
+    >>> f = Function('f')
+    >>> x = Symbol('x')
+    >>> d = DifferentialOperator(1/x*Derivative(f(x), x), f(x))
+    >>> w = Wavefunction(x**2, x)
+    >>> d.function
+    f(x)
+    >>> d.variables
+    (x,)
+    >>> qapply(d*w)
+    Wavefunction(2, x)
+
+    """
+
+    @property
+    def variables(self):
+        """
+        Returns the variables with which the function in the specified
+        arbitrary expression is evaluated
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.operator import DifferentialOperator
+        >>> from sympy import Symbol, Function, Derivative
+        >>> x = Symbol('x')
+        >>> f = Function('f')
+        >>> d = DifferentialOperator(1/x*Derivative(f(x), x), f(x))
+        >>> d.variables
+        (x,)
+        >>> y = Symbol('y')
+        >>> d = DifferentialOperator(Derivative(f(x, y), x) +
+        ...                          Derivative(f(x, y), y), f(x, y))
+        >>> d.variables
+        (x, y)
+        """
+
+        return self.args[-1].args
+
+    @property
+    def function(self):
+        """
+        Returns the function which is to be replaced with the Wavefunction
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.operator import DifferentialOperator
+        >>> from sympy import Function, Symbol, Derivative
+        >>> x = Symbol('x')
+        >>> f = Function('f')
+        >>> d = DifferentialOperator(Derivative(f(x), x), f(x))
+        >>> d.function
+        f(x)
+        >>> y = Symbol('y')
+        >>> d = DifferentialOperator(Derivative(f(x, y), x) +
+        ...                          Derivative(f(x, y), y), f(x, y))
+        >>> d.function
+        f(x, y)
+        """
+
+        return self.args[-1]
+
+    @property
+    def expr(self):
+        """
+        Returns the arbitrary expression which is to have the Wavefunction
+        substituted into it
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.operator import DifferentialOperator
+        >>> from sympy import Function, Symbol, Derivative
+        >>> x = Symbol('x')
+        >>> f = Function('f')
+        >>> d = DifferentialOperator(Derivative(f(x), x), f(x))
+        >>> d.expr
+        Derivative(f(x), x)
+        >>> y = Symbol('y')
+        >>> d = DifferentialOperator(Derivative(f(x, y), x) +
+        ...                          Derivative(f(x, y), y), f(x, y))
+        >>> d.expr
+        Derivative(f(x, y), x) + Derivative(f(x, y), y)
+        """
+
+        return self.args[0]
+
+    @property
+    def free_symbols(self):
+        """
+        Return the free symbols of the expression.
+        """
+
+        return self.expr.free_symbols
+
+    def _apply_operator_Wavefunction(self, func, **options):
+        from sympy.physics.quantum.state import Wavefunction
+        var = self.variables
+        wf_vars = func.args[1:]
+
+        f = self.function
+        new_expr = self.expr.subs(f, func(*var))
+        new_expr = new_expr.doit()
+
+        return Wavefunction(new_expr, *wf_vars)
+
+    def _eval_derivative(self, symbol):
+        new_expr = Derivative(self.expr, symbol)
+        return DifferentialOperator(new_expr, self.args[-1])
+
+    #-------------------------------------------------------------------------
+    # Printing
+    #-------------------------------------------------------------------------
+
+    def _print(self, printer, *args):
+        return '%s(%s)' % (
+            self._print_operator_name(printer, *args),
+            self._print_label(printer, *args)
+        )
+
+    def _print_pretty(self, printer, *args):
+        pform = self._print_operator_name_pretty(printer, *args)
+        label_pform = self._print_label_pretty(printer, *args)
+        label_pform = prettyForm(
+            *label_pform.parens(left='(', right=')')
+        )
+        pform = prettyForm(*pform.right(label_pform))
+        return pform

venv/lib/python3.10/site-packages/sympy/physics/quantum/operatorordering.py

@@ -0,0 +1,329 @@
+"""Functions for reordering operator expressions."""
+
+import warnings
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer
+from sympy.core.power import Pow
+from sympy.physics.quantum import Operator, Commutator, AntiCommutator
+from sympy.physics.quantum.boson import BosonOp
+from sympy.physics.quantum.fermion import FermionOp
+
+__all__ = [
+    'normal_order',
+    'normal_ordered_form'
+]
+
+
+def _expand_powers(factors):
+    """
+    Helper function for normal_ordered_form and normal_order: Expand a
+    power expression to a multiplication expression so that that the
+    expression can be handled by the normal ordering functions.
+    """
+
+    new_factors = []
+    for factor in factors.args:
+        if (isinstance(factor, Pow)
+                and isinstance(factor.args[1], Integer)
+                and factor.args[1] > 0):
+            for n in range(factor.args[1]):
+                new_factors.append(factor.args[0])
+        else:
+            new_factors.append(factor)
+
+    return new_factors
+
+
+def _normal_ordered_form_factor(product, independent=False, recursive_limit=10,
+                                _recursive_depth=0):
+    """
+    Helper function for normal_ordered_form_factor: Write multiplication
+    expression with bosonic or fermionic operators on normally ordered form,
+    using the bosonic and fermionic commutation relations. The resulting
+    operator expression is equivalent to the argument, but will in general be
+    a sum of operator products instead of a simple product.
+    """
+
+    factors = _expand_powers(product)
+
+    new_factors = []
+    n = 0
+    while n < len(factors) - 1:
+
+        if isinstance(factors[n], BosonOp):
+            # boson
+            if not isinstance(factors[n + 1], BosonOp):
+                new_factors.append(factors[n])
+
+            elif factors[n].is_annihilation == factors[n + 1].is_annihilation:
+                if (independent and
+                        str(factors[n].name) > str(factors[n + 1].name)):
+                    new_factors.append(factors[n + 1])
+                    new_factors.append(factors[n])
+                    n += 1
+                else:
+                    new_factors.append(factors[n])
+
+            elif not factors[n].is_annihilation:
+                new_factors.append(factors[n])
+
+            else:
+                if factors[n + 1].is_annihilation:
+                    new_factors.append(factors[n])
+                else:
+                    if factors[n].args[0] != factors[n + 1].args[0]:
+                        if independent:
+                            c = 0
+                        else:
+                            c = Commutator(factors[n], factors[n + 1])
+                        new_factors.append(factors[n + 1] * factors[n] + c)
+                    else:
+                        c = Commutator(factors[n], factors[n + 1])
+                        new_factors.append(
+                            factors[n + 1] * factors[n] + c.doit())
+                    n += 1
+
+        elif isinstance(factors[n], FermionOp):
+            # fermion
+            if not isinstance(factors[n + 1], FermionOp):
+                new_factors.append(factors[n])
+
+            elif factors[n].is_annihilation == factors[n + 1].is_annihilation:
+                if (independent and
+                        str(factors[n].name) > str(factors[n + 1].name)):
+                    new_factors.append(factors[n + 1])
+                    new_factors.append(factors[n])
+                    n += 1
+                else:
+                    new_factors.append(factors[n])
+
+            elif not factors[n].is_annihilation:
+                new_factors.append(factors[n])
+
+            else:
+                if factors[n + 1].is_annihilation:
+                    new_factors.append(factors[n])
+                else:
+                    if factors[n].args[0] != factors[n + 1].args[0]:
+                        if independent:
+                            c = 0
+                        else:
+                            c = AntiCommutator(factors[n], factors[n + 1])
+                        new_factors.append(-factors[n + 1] * factors[n] + c)
+                    else:
+                        c = AntiCommutator(factors[n], factors[n + 1])
+                        new_factors.append(
+                            -factors[n + 1] * factors[n] + c.doit())
+                    n += 1
+
+        elif isinstance(factors[n], Operator):
+
+            if isinstance(factors[n + 1], (BosonOp, FermionOp)):
+                new_factors.append(factors[n + 1])
+                new_factors.append(factors[n])
+                n += 1
+            else:
+                new_factors.append(factors[n])
+
+        else:
+            new_factors.append(factors[n])
+
+        n += 1
+
+    if n == len(factors) - 1:
+        new_factors.append(factors[-1])
+
+    if new_factors == factors:
+        return product
+    else:
+        expr = Mul(*new_factors).expand()
+        return normal_ordered_form(expr,
+                                   recursive_limit=recursive_limit,
+                                   _recursive_depth=_recursive_depth + 1,
+                                   independent=independent)
+
+
+def _normal_ordered_form_terms(expr, independent=False, recursive_limit=10,
+                               _recursive_depth=0):
+    """
+    Helper function for normal_ordered_form: loop through each term in an
+    addition expression and call _normal_ordered_form_factor to perform the
+    factor to an normally ordered expression.
+    """
+
+    new_terms = []
+    for term in expr.args:
+        if isinstance(term, Mul):
+            new_term = _normal_ordered_form_factor(
+                term, recursive_limit=recursive_limit,
+                _recursive_depth=_recursive_depth, independent=independent)
+            new_terms.append(new_term)
+        else:
+            new_terms.append(term)
+
+    return Add(*new_terms)
+
+
+def normal_ordered_form(expr, independent=False, recursive_limit=10,
+                        _recursive_depth=0):
+    """Write an expression with bosonic or fermionic operators on normal
+    ordered form, where each term is normally ordered. Note that this
+    normal ordered form is equivalent to the original expression.
+
+    Parameters
+    ==========
+
+    expr : expression
+        The expression write on normal ordered form.
+
+    recursive_limit : int (default 10)
+        The number of allowed recursive applications of the function.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import Dagger
+    >>> from sympy.physics.quantum.boson import BosonOp
+    >>> from sympy.physics.quantum.operatorordering import normal_ordered_form
+    >>> a = BosonOp("a")
+    >>> normal_ordered_form(a * Dagger(a))
+    1 + Dagger(a)*a
+    """
+
+    if _recursive_depth > recursive_limit:
+        warnings.warn("Too many recursions, aborting")
+        return expr
+
+    if isinstance(expr, Add):
+        return _normal_ordered_form_terms(expr,
+                                          recursive_limit=recursive_limit,
+                                          _recursive_depth=_recursive_depth,
+                                          independent=independent)
+    elif isinstance(expr, Mul):
+        return _normal_ordered_form_factor(expr,
+                                           recursive_limit=recursive_limit,
+                                           _recursive_depth=_recursive_depth,
+                                           independent=independent)
+    else:
+        return expr
+
+
+def _normal_order_factor(product, recursive_limit=10, _recursive_depth=0):
+    """
+    Helper function for normal_order: Normal order a multiplication expression
+    with bosonic or fermionic operators. In general the resulting operator
+    expression will not be equivalent to original product.
+    """
+
+    factors = _expand_powers(product)
+
+    n = 0
+    new_factors = []
+    while n < len(factors) - 1:
+
+        if (isinstance(factors[n], BosonOp) and
+                factors[n].is_annihilation):
+            # boson
+            if not isinstance(factors[n + 1], BosonOp):
+                new_factors.append(factors[n])
+            else:
+                if factors[n + 1].is_annihilation:
+                    new_factors.append(factors[n])
+                else:
+                    if factors[n].args[0] != factors[n + 1].args[0]:
+                        new_factors.append(factors[n + 1] * factors[n])
+                    else:
+                        new_factors.append(factors[n + 1] * factors[n])
+                    n += 1
+
+        elif (isinstance(factors[n], FermionOp) and
+              factors[n].is_annihilation):
+            # fermion
+            if not isinstance(factors[n + 1], FermionOp):
+                new_factors.append(factors[n])
+            else:
+                if factors[n + 1].is_annihilation:
+                    new_factors.append(factors[n])
+                else:
+                    if factors[n].args[0] != factors[n + 1].args[0]:
+                        new_factors.append(-factors[n + 1] * factors[n])
+                    else:
+                        new_factors.append(-factors[n + 1] * factors[n])
+                    n += 1
+
+        else:
+            new_factors.append(factors[n])
+
+        n += 1
+
+    if n == len(factors) - 1:
+        new_factors.append(factors[-1])
+
+    if new_factors == factors:
+        return product
+    else:
+        expr = Mul(*new_factors).expand()
+        return normal_order(expr,
+                            recursive_limit=recursive_limit,
+                            _recursive_depth=_recursive_depth + 1)
+
+
+def _normal_order_terms(expr, recursive_limit=10, _recursive_depth=0):
+    """
+    Helper function for normal_order: look through each term in an addition
+    expression and call _normal_order_factor to perform the normal ordering
+    on the factors.
+    """
+
+    new_terms = []
+    for term in expr.args:
+        if isinstance(term, Mul):
+            new_term = _normal_order_factor(term,
+                                            recursive_limit=recursive_limit,
+                                            _recursive_depth=_recursive_depth)
+            new_terms.append(new_term)
+        else:
+            new_terms.append(term)
+
+    return Add(*new_terms)
+
+
+def normal_order(expr, recursive_limit=10, _recursive_depth=0):
+    """Normal order an expression with bosonic or fermionic operators. Note
+    that this normal order is not equivalent to the original expression, but
+    the creation and annihilation operators in each term in expr is reordered
+    so that the expression becomes normal ordered.
+
+    Parameters
+    ==========
+
+    expr : expression
+        The expression to normal order.
+
+    recursive_limit : int (default 10)
+        The number of allowed recursive applications of the function.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import Dagger
+    >>> from sympy.physics.quantum.boson import BosonOp
+    >>> from sympy.physics.quantum.operatorordering import normal_order
+    >>> a = BosonOp("a")
+    >>> normal_order(a * Dagger(a))
+    Dagger(a)*a
+    """
+    if _recursive_depth > recursive_limit:
+        warnings.warn("Too many recursions, aborting")
+        return expr
+
+    if isinstance(expr, Add):
+        return _normal_order_terms(expr, recursive_limit=recursive_limit,
+                                   _recursive_depth=_recursive_depth)
+    elif isinstance(expr, Mul):
+        return _normal_order_factor(expr, recursive_limit=recursive_limit,
+                                    _recursive_depth=_recursive_depth)
+    else:
+        return expr

venv/lib/python3.10/site-packages/sympy/physics/quantum/operatorset.py

@@ -0,0 +1,280 @@
+""" A module for mapping operators to their corresponding eigenstates
+and vice versa
+
+It contains a global dictionary with eigenstate-operator pairings.
+If a new state-operator pair is created, this dictionary should be
+updated as well.
+
+It also contains functions operators_to_state and state_to_operators
+for mapping between the two. These can handle both classes and
+instances of operators and states. See the individual function
+descriptions for details.
+
+TODO List:
+- Update the dictionary with a complete list of state-operator pairs
+"""
+
+from sympy.physics.quantum.cartesian import (XOp, YOp, ZOp, XKet, PxOp, PxKet,
+                                             PositionKet3D)
+from sympy.physics.quantum.operator import Operator
+from sympy.physics.quantum.state import StateBase, BraBase, Ket
+from sympy.physics.quantum.spin import (JxOp, JyOp, JzOp, J2Op, JxKet, JyKet,
+                                        JzKet)
+
+__all__ = [
+    'operators_to_state',
+    'state_to_operators'
+]
+
+#state_mapping stores the mappings between states and their associated
+#operators or tuples of operators. This should be updated when new
+#classes are written! Entries are of the form PxKet : PxOp or
+#something like 3DKet : (ROp, ThetaOp, PhiOp)
+
+#frozenset is used so that the reverse mapping can be made
+#(regular sets are not hashable because they are mutable
+state_mapping = { JxKet: frozenset((J2Op, JxOp)),
+                  JyKet: frozenset((J2Op, JyOp)),
+                  JzKet: frozenset((J2Op, JzOp)),
+                  Ket: Operator,
+                  PositionKet3D: frozenset((XOp, YOp, ZOp)),
+                  PxKet: PxOp,
+                  XKet: XOp }
+
+op_mapping = {v: k for k, v in state_mapping.items()}
+
+
+def operators_to_state(operators, **options):
+    """ Returns the eigenstate of the given operator or set of operators
+
+    A global function for mapping operator classes to their associated
+    states. It takes either an Operator or a set of operators and
+    returns the state associated with these.
+
+    This function can handle both instances of a given operator or
+    just the class itself (i.e. both XOp() and XOp)
+
+    There are multiple use cases to consider:
+
+    1) A class or set of classes is passed: First, we try to
+    instantiate default instances for these operators. If this fails,
+    then the class is simply returned. If we succeed in instantiating
+    default instances, then we try to call state._operators_to_state
+    on the operator instances. If this fails, the class is returned.
+    Otherwise, the instance returned by _operators_to_state is returned.
+
+    2) An instance or set of instances is passed: In this case,
+    state._operators_to_state is called on the instances passed. If
+    this fails, a state class is returned. If the method returns an
+    instance, that instance is returned.
+
+    In both cases, if the operator class or set does not exist in the
+    state_mapping dictionary, None is returned.
+
+    Parameters
+    ==========
+
+    arg: Operator or set
+         The class or instance of the operator or set of operators
+         to be mapped to a state
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.cartesian import XOp, PxOp
+    >>> from sympy.physics.quantum.operatorset import operators_to_state
+    >>> from sympy.physics.quantum.operator import Operator
+    >>> operators_to_state(XOp)
+    |x>
+    >>> operators_to_state(XOp())
+    |x>
+    >>> operators_to_state(PxOp)
+    |px>
+    >>> operators_to_state(PxOp())
+    |px>
+    >>> operators_to_state(Operator)
+    |psi>
+    >>> operators_to_state(Operator())
+    |psi>
+    """
+
+    if not (isinstance(operators, Operator)
+            or isinstance(operators, set) or issubclass(operators, Operator)):
+        raise NotImplementedError("Argument is not an Operator or a set!")
+
+    if isinstance(operators, set):
+        for s in operators:
+            if not (isinstance(s, Operator)
+                   or issubclass(s, Operator)):
+                raise NotImplementedError("Set is not all Operators!")
+
+        ops = frozenset(operators)
+
+        if ops in op_mapping:  # ops is a list of classes in this case
+            #Try to get an object from default instances of the
+            #operators...if this fails, return the class
+            try:
+                op_instances = [op() for op in ops]
+                ret = _get_state(op_mapping[ops], set(op_instances), **options)
+            except NotImplementedError:
+                ret = op_mapping[ops]
+
+            return ret
+        else:
+            tmp = [type(o) for o in ops]
+            classes = frozenset(tmp)
+
+            if classes in op_mapping:
+                ret = _get_state(op_mapping[classes], ops, **options)
+            else:
+                ret = None
+
+            return ret
+    else:
+        if operators in op_mapping:
+            try:
+                op_instance = operators()
+                ret = _get_state(op_mapping[operators], op_instance, **options)
+            except NotImplementedError:
+                ret = op_mapping[operators]
+
+            return ret
+        elif type(operators) in op_mapping:
+            return _get_state(op_mapping[type(operators)], operators, **options)
+        else:
+            return None
+
+
+def state_to_operators(state, **options):
+    """ Returns the operator or set of operators corresponding to the
+    given eigenstate
+
+    A global function for mapping state classes to their associated
+    operators or sets of operators. It takes either a state class
+    or instance.
+
+    This function can handle both instances of a given state or just
+    the class itself (i.e. both XKet() and XKet)
+
+    There are multiple use cases to consider:
+
+    1) A state class is passed: In this case, we first try
+    instantiating a default instance of the class. If this succeeds,
+    then we try to call state._state_to_operators on that instance.
+    If the creation of the default instance or if the calling of
+    _state_to_operators fails, then either an operator class or set of
+    operator classes is returned. Otherwise, the appropriate
+    operator instances are returned.
+
+    2) A state instance is returned: Here, state._state_to_operators
+    is called for the instance. If this fails, then a class or set of
+    operator classes is returned. Otherwise, the instances are returned.
+
+    In either case, if the state's class does not exist in
+    state_mapping, None is returned.
+
+    Parameters
+    ==========
+
+    arg: StateBase class or instance (or subclasses)
+         The class or instance of the state to be mapped to an
+         operator or set of operators
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.cartesian import XKet, PxKet, XBra, PxBra
+    >>> from sympy.physics.quantum.operatorset import state_to_operators
+    >>> from sympy.physics.quantum.state import Ket, Bra
+    >>> state_to_operators(XKet)
+    X
+    >>> state_to_operators(XKet())
+    X
+    >>> state_to_operators(PxKet)
+    Px
+    >>> state_to_operators(PxKet())
+    Px
+    >>> state_to_operators(PxBra)
+    Px
+    >>> state_to_operators(XBra)
+    X
+    >>> state_to_operators(Ket)
+    O
+    >>> state_to_operators(Bra)
+    O
+    """
+
+    if not (isinstance(state, StateBase) or issubclass(state, StateBase)):
+        raise NotImplementedError("Argument is not a state!")
+
+    if state in state_mapping:  # state is a class
+        state_inst = _make_default(state)
+        try:
+            ret = _get_ops(state_inst,
+                           _make_set(state_mapping[state]), **options)
+        except (NotImplementedError, TypeError):
+            ret = state_mapping[state]
+    elif type(state) in state_mapping:
+        ret = _get_ops(state,
+                       _make_set(state_mapping[type(state)]), **options)
+    elif isinstance(state, BraBase) and state.dual_class() in state_mapping:
+        ret = _get_ops(state,
+                       _make_set(state_mapping[state.dual_class()]))
+    elif issubclass(state, BraBase) and state.dual_class() in state_mapping:
+        state_inst = _make_default(state)
+        try:
+            ret = _get_ops(state_inst,
+                           _make_set(state_mapping[state.dual_class()]))
+        except (NotImplementedError, TypeError):
+            ret = state_mapping[state.dual_class()]
+    else:
+        ret = None
+
+    return _make_set(ret)
+
+
+def _make_default(expr):
+    # XXX: Catching TypeError like this is a bad way of distinguishing between
+    # classes and instances. The logic using this function should be rewritten
+    # somehow.
+    try:
+        ret = expr()
+    except TypeError:
+        ret = expr
+
+    return ret
+
+
+def _get_state(state_class, ops, **options):
+    # Try to get a state instance from the operator INSTANCES.
+    # If this fails, get the class
+    try:
+        ret = state_class._operators_to_state(ops, **options)
+    except NotImplementedError:
+        ret = _make_default(state_class)
+
+    return ret
+
+
+def _get_ops(state_inst, op_classes, **options):
+    # Try to get operator instances from the state INSTANCE.
+    # If this fails, just return the classes
+    try:
+        ret = state_inst._state_to_operators(op_classes, **options)
+    except NotImplementedError:
+        if isinstance(op_classes, (set, tuple, frozenset)):
+            ret = tuple(_make_default(x) for x in op_classes)
+        else:
+            ret = _make_default(op_classes)
+
+    if isinstance(ret, set) and len(ret) == 1:
+        return ret[0]
+
+    return ret
+
+
+def _make_set(ops):
+    if isinstance(ops, (tuple, list, frozenset)):
+        return set(ops)
+    else:
+        return ops

venv/lib/python3.10/site-packages/sympy/physics/quantum/pauli.py

@@ -0,0 +1,675 @@
+"""Pauli operators and states"""
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import I
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.physics.quantum import Operator, Ket, Bra
+from sympy.physics.quantum import ComplexSpace
+from sympy.matrices import Matrix
+from sympy.functions.special.tensor_functions import KroneckerDelta
+
+__all__ = [
+    'SigmaX', 'SigmaY', 'SigmaZ', 'SigmaMinus', 'SigmaPlus', 'SigmaZKet',
+    'SigmaZBra', 'qsimplify_pauli'
+]
+
+
+class SigmaOpBase(Operator):
+    """Pauli sigma operator, base class"""
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def use_name(self):
+        return bool(self.args[0]) is not False
+
+    @classmethod
+    def default_args(self):
+        return (False,)
+
+    def __new__(cls, *args, **hints):
+        return Operator.__new__(cls, *args, **hints)
+
+    def _eval_commutator_BosonOp(self, other, **hints):
+        return S.Zero
+
+
+class SigmaX(SigmaOpBase):
+    """Pauli sigma x operator
+
+    Parameters
+    ==========
+
+    name : str
+        An optional string that labels the operator. Pauli operators with
+        different names commute.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import represent
+    >>> from sympy.physics.quantum.pauli import SigmaX
+    >>> sx = SigmaX()
+    >>> sx
+    SigmaX()
+    >>> represent(sx)
+    Matrix([
+    [0, 1],
+    [1, 0]])
+    """
+
+    def __new__(cls, *args, **hints):
+        return SigmaOpBase.__new__(cls, *args, **hints)
+
+    def _eval_commutator_SigmaY(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return 2 * I * SigmaZ(self.name)
+
+    def _eval_commutator_SigmaZ(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return - 2 * I * SigmaY(self.name)
+
+    def _eval_commutator_BosonOp(self, other, **hints):
+        return S.Zero
+
+    def _eval_anticommutator_SigmaY(self, other, **hints):
+        return S.Zero
+
+    def _eval_anticommutator_SigmaZ(self, other, **hints):
+        return S.Zero
+
+    def _eval_adjoint(self):
+        return self
+
+    def _print_contents_latex(self, printer, *args):
+        if self.use_name:
+            return r'{\sigma_x^{(%s)}}' % str(self.name)
+        else:
+            return r'{\sigma_x}'
+
+    def _print_contents(self, printer, *args):
+        return 'SigmaX()'
+
+    def _eval_power(self, e):
+        if e.is_Integer and e.is_positive:
+            return SigmaX(self.name).__pow__(int(e) % 2)
+
+    def _represent_default_basis(self, **options):
+        format = options.get('format', 'sympy')
+        if format == 'sympy':
+            return Matrix([[0, 1], [1, 0]])
+        else:
+            raise NotImplementedError('Representation in format ' +
+                                      format + ' not implemented.')
+
+
+class SigmaY(SigmaOpBase):
+    """Pauli sigma y operator
+
+    Parameters
+    ==========
+
+    name : str
+        An optional string that labels the operator. Pauli operators with
+        different names commute.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import represent
+    >>> from sympy.physics.quantum.pauli import SigmaY
+    >>> sy = SigmaY()
+    >>> sy
+    SigmaY()
+    >>> represent(sy)
+    Matrix([
+    [0, -I],
+    [I,  0]])
+    """
+
+    def __new__(cls, *args, **hints):
+        return SigmaOpBase.__new__(cls, *args)
+
+    def _eval_commutator_SigmaZ(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return 2 * I * SigmaX(self.name)
+
+    def _eval_commutator_SigmaX(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return - 2 * I * SigmaZ(self.name)
+
+    def _eval_anticommutator_SigmaX(self, other, **hints):
+        return S.Zero
+
+    def _eval_anticommutator_SigmaZ(self, other, **hints):
+        return S.Zero
+
+    def _eval_adjoint(self):
+        return self
+
+    def _print_contents_latex(self, printer, *args):
+        if self.use_name:
+            return r'{\sigma_y^{(%s)}}' % str(self.name)
+        else:
+            return r'{\sigma_y}'
+
+    def _print_contents(self, printer, *args):
+        return 'SigmaY()'
+
+    def _eval_power(self, e):
+        if e.is_Integer and e.is_positive:
+            return SigmaY(self.name).__pow__(int(e) % 2)
+
+    def _represent_default_basis(self, **options):
+        format = options.get('format', 'sympy')
+        if format == 'sympy':
+            return Matrix([[0, -I], [I, 0]])
+        else:
+            raise NotImplementedError('Representation in format ' +
+                                      format + ' not implemented.')
+
+
+class SigmaZ(SigmaOpBase):
+    """Pauli sigma z operator
+
+    Parameters
+    ==========
+
+    name : str
+        An optional string that labels the operator. Pauli operators with
+        different names commute.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import represent
+    >>> from sympy.physics.quantum.pauli import SigmaZ
+    >>> sz = SigmaZ()
+    >>> sz ** 3
+    SigmaZ()
+    >>> represent(sz)
+    Matrix([
+    [1,  0],
+    [0, -1]])
+    """
+
+    def __new__(cls, *args, **hints):
+        return SigmaOpBase.__new__(cls, *args)
+
+    def _eval_commutator_SigmaX(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return 2 * I * SigmaY(self.name)
+
+    def _eval_commutator_SigmaY(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return - 2 * I * SigmaX(self.name)
+
+    def _eval_anticommutator_SigmaX(self, other, **hints):
+        return S.Zero
+
+    def _eval_anticommutator_SigmaY(self, other, **hints):
+        return S.Zero
+
+    def _eval_adjoint(self):
+        return self
+
+    def _print_contents_latex(self, printer, *args):
+        if self.use_name:
+            return r'{\sigma_z^{(%s)}}' % str(self.name)
+        else:
+            return r'{\sigma_z}'
+
+    def _print_contents(self, printer, *args):
+        return 'SigmaZ()'
+
+    def _eval_power(self, e):
+        if e.is_Integer and e.is_positive:
+            return SigmaZ(self.name).__pow__(int(e) % 2)
+
+    def _represent_default_basis(self, **options):
+        format = options.get('format', 'sympy')
+        if format == 'sympy':
+            return Matrix([[1, 0], [0, -1]])
+        else:
+            raise NotImplementedError('Representation in format ' +
+                                      format + ' not implemented.')
+
+
+class SigmaMinus(SigmaOpBase):
+    """Pauli sigma minus operator
+
+    Parameters
+    ==========
+
+    name : str
+        An optional string that labels the operator. Pauli operators with
+        different names commute.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import represent, Dagger
+    >>> from sympy.physics.quantum.pauli import SigmaMinus
+    >>> sm = SigmaMinus()
+    >>> sm
+    SigmaMinus()
+    >>> Dagger(sm)
+    SigmaPlus()
+    >>> represent(sm)
+    Matrix([
+    [0, 0],
+    [1, 0]])
+    """
+
+    def __new__(cls, *args, **hints):
+        return SigmaOpBase.__new__(cls, *args)
+
+    def _eval_commutator_SigmaX(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return -SigmaZ(self.name)
+
+    def _eval_commutator_SigmaY(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return I * SigmaZ(self.name)
+
+    def _eval_commutator_SigmaZ(self, other, **hints):
+        return 2 * self
+
+    def _eval_commutator_SigmaMinus(self, other, **hints):
+        return SigmaZ(self.name)
+
+    def _eval_anticommutator_SigmaZ(self, other, **hints):
+        return S.Zero
+
+    def _eval_anticommutator_SigmaX(self, other, **hints):
+        return S.One
+
+    def _eval_anticommutator_SigmaY(self, other, **hints):
+        return I * S.NegativeOne
+
+    def _eval_anticommutator_SigmaPlus(self, other, **hints):
+        return S.One
+
+    def _eval_adjoint(self):
+        return SigmaPlus(self.name)
+
+    def _eval_power(self, e):
+        if e.is_Integer and e.is_positive:
+            return S.Zero
+
+    def _print_contents_latex(self, printer, *args):
+        if self.use_name:
+            return r'{\sigma_-^{(%s)}}' % str(self.name)
+        else:
+            return r'{\sigma_-}'
+
+    def _print_contents(self, printer, *args):
+        return 'SigmaMinus()'
+
+    def _represent_default_basis(self, **options):
+        format = options.get('format', 'sympy')
+        if format == 'sympy':
+            return Matrix([[0, 0], [1, 0]])
+        else:
+            raise NotImplementedError('Representation in format ' +
+                                      format + ' not implemented.')
+
+
+class SigmaPlus(SigmaOpBase):
+    """Pauli sigma plus operator
+
+    Parameters
+    ==========
+
+    name : str
+        An optional string that labels the operator. Pauli operators with
+        different names commute.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum import represent, Dagger
+    >>> from sympy.physics.quantum.pauli import SigmaPlus
+    >>> sp = SigmaPlus()
+    >>> sp
+    SigmaPlus()
+    >>> Dagger(sp)
+    SigmaMinus()
+    >>> represent(sp)
+    Matrix([
+    [0, 1],
+    [0, 0]])
+    """
+
+    def __new__(cls, *args, **hints):
+        return SigmaOpBase.__new__(cls, *args)
+
+    def _eval_commutator_SigmaX(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return SigmaZ(self.name)
+
+    def _eval_commutator_SigmaY(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return I * SigmaZ(self.name)
+
+    def _eval_commutator_SigmaZ(self, other, **hints):
+        if self.name != other.name:
+            return S.Zero
+        else:
+            return -2 * self
+
+    def _eval_commutator_SigmaMinus(self, other, **hints):
+        return SigmaZ(self.name)
+
+    def _eval_anticommutator_SigmaZ(self, other, **hints):
+        return S.Zero
+
+    def _eval_anticommutator_SigmaX(self, other, **hints):
+        return S.One
+
+    def _eval_anticommutator_SigmaY(self, other, **hints):
+        return I
+
+    def _eval_anticommutator_SigmaMinus(self, other, **hints):
+        return S.One
+
+    def _eval_adjoint(self):
+        return SigmaMinus(self.name)
+
+    def _eval_mul(self, other):
+        return self * other
+
+    def _eval_power(self, e):
+        if e.is_Integer and e.is_positive:
+            return S.Zero
+
+    def _print_contents_latex(self, printer, *args):
+        if self.use_name:
+            return r'{\sigma_+^{(%s)}}' % str(self.name)
+        else:
+            return r'{\sigma_+}'
+
+    def _print_contents(self, printer, *args):
+        return 'SigmaPlus()'
+
+    def _represent_default_basis(self, **options):
+        format = options.get('format', 'sympy')
+        if format == 'sympy':
+            return Matrix([[0, 1], [0, 0]])
+        else:
+            raise NotImplementedError('Representation in format ' +
+                                      format + ' not implemented.')
+
+
+class SigmaZKet(Ket):
+    """Ket for a two-level system quantum system.
+
+    Parameters
+    ==========
+
+    n : Number
+        The state number (0 or 1).
+
+    """
+
+    def __new__(cls, n):
+        if n not in (0, 1):
+            raise ValueError("n must be 0 or 1")
+        return Ket.__new__(cls, n)
+
+    @property
+    def n(self):
+        return self.label[0]
+
+    @classmethod
+    def dual_class(self):
+        return SigmaZBra
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return ComplexSpace(2)
+
+    def _eval_innerproduct_SigmaZBra(self, bra, **hints):
+        return KroneckerDelta(self.n, bra.n)
+
+    def _apply_from_right_to_SigmaZ(self, op, **options):
+        if self.n == 0:
+            return self
+        else:
+            return S.NegativeOne * self
+
+    def _apply_from_right_to_SigmaX(self, op, **options):
+        return SigmaZKet(1) if self.n == 0 else SigmaZKet(0)
+
+    def _apply_from_right_to_SigmaY(self, op, **options):
+        return I * SigmaZKet(1) if self.n == 0 else (-I) * SigmaZKet(0)
+
+    def _apply_from_right_to_SigmaMinus(self, op, **options):
+        if self.n == 0:
+            return SigmaZKet(1)
+        else:
+            return S.Zero
+
+    def _apply_from_right_to_SigmaPlus(self, op, **options):
+        if self.n == 0:
+            return S.Zero
+        else:
+            return SigmaZKet(0)
+
+    def _represent_default_basis(self, **options):
+        format = options.get('format', 'sympy')
+        if format == 'sympy':
+            return Matrix([[1], [0]]) if self.n == 0 else Matrix([[0], [1]])
+        else:
+            raise NotImplementedError('Representation in format ' +
+                                      format + ' not implemented.')
+
+
+class SigmaZBra(Bra):
+    """Bra for a two-level quantum system.
+
+    Parameters
+    ==========
+
+    n : Number
+        The state number (0 or 1).
+
+    """
+
+    def __new__(cls, n):
+        if n not in (0, 1):
+            raise ValueError("n must be 0 or 1")
+        return Bra.__new__(cls, n)
+
+    @property
+    def n(self):
+        return self.label[0]
+
+    @classmethod
+    def dual_class(self):
+        return SigmaZKet
+
+
+def _qsimplify_pauli_product(a, b):
+    """
+    Internal helper function for simplifying products of Pauli operators.
+    """
+    if not (isinstance(a, SigmaOpBase) and isinstance(b, SigmaOpBase)):
+        return Mul(a, b)
+
+    if a.name != b.name:
+        # Pauli matrices with different labels commute; sort by name
+        if a.name < b.name:
+            return Mul(a, b)
+        else:
+            return Mul(b, a)
+
+    elif isinstance(a, SigmaX):
+
+        if isinstance(b, SigmaX):
+            return S.One
+
+        if isinstance(b, SigmaY):
+            return I * SigmaZ(a.name)
+
+        if isinstance(b, SigmaZ):
+            return - I * SigmaY(a.name)
+
+        if isinstance(b, SigmaMinus):
+            return (S.Half + SigmaZ(a.name)/2)
+
+        if isinstance(b, SigmaPlus):
+            return (S.Half - SigmaZ(a.name)/2)
+
+    elif isinstance(a, SigmaY):
+
+        if isinstance(b, SigmaX):
+            return - I * SigmaZ(a.name)
+
+        if isinstance(b, SigmaY):
+            return S.One
+
+        if isinstance(b, SigmaZ):
+            return I * SigmaX(a.name)
+
+        if isinstance(b, SigmaMinus):
+            return -I * (S.One + SigmaZ(a.name))/2
+
+        if isinstance(b, SigmaPlus):
+            return I * (S.One - SigmaZ(a.name))/2
+
+    elif isinstance(a, SigmaZ):
+
+        if isinstance(b, SigmaX):
+            return I * SigmaY(a.name)
+
+        if isinstance(b, SigmaY):
+            return - I * SigmaX(a.name)
+
+        if isinstance(b, SigmaZ):
+            return S.One
+
+        if isinstance(b, SigmaMinus):
+            return - SigmaMinus(a.name)
+
+        if isinstance(b, SigmaPlus):
+            return SigmaPlus(a.name)
+
+    elif isinstance(a, SigmaMinus):
+
+        if isinstance(b, SigmaX):
+            return (S.One - SigmaZ(a.name))/2
+
+        if isinstance(b, SigmaY):
+            return - I * (S.One - SigmaZ(a.name))/2
+
+        if isinstance(b, SigmaZ):
+            # (SigmaX(a.name) - I * SigmaY(a.name))/2
+            return SigmaMinus(b.name)
+
+        if isinstance(b, SigmaMinus):
+            return S.Zero
+
+        if isinstance(b, SigmaPlus):
+            return S.Half - SigmaZ(a.name)/2
+
+    elif isinstance(a, SigmaPlus):
+
+        if isinstance(b, SigmaX):
+            return (S.One + SigmaZ(a.name))/2
+
+        if isinstance(b, SigmaY):
+            return I * (S.One + SigmaZ(a.name))/2
+
+        if isinstance(b, SigmaZ):
+            #-(SigmaX(a.name) + I * SigmaY(a.name))/2
+            return -SigmaPlus(a.name)
+
+        if isinstance(b, SigmaMinus):
+            return (S.One + SigmaZ(a.name))/2
+
+        if isinstance(b, SigmaPlus):
+            return S.Zero
+
+    else:
+        return a * b
+
+
+def qsimplify_pauli(e):
+    """
+    Simplify an expression that includes products of pauli operators.
+
+    Parameters
+    ==========
+
+    e : expression
+        An expression that contains products of Pauli operators that is
+        to be simplified.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.pauli import SigmaX, SigmaY
+    >>> from sympy.physics.quantum.pauli import qsimplify_pauli
+    >>> sx, sy = SigmaX(), SigmaY()
+    >>> sx * sy
+    SigmaX()*SigmaY()
+    >>> qsimplify_pauli(sx * sy)
+    I*SigmaZ()
+    """
+    if isinstance(e, Operator):
+        return e
+
+    if isinstance(e, (Add, Pow, exp)):
+        t = type(e)
+        return t(*(qsimplify_pauli(arg) for arg in e.args))
+
+    if isinstance(e, Mul):
+
+        c, nc = e.args_cnc()
+
+        nc_s = []
+        while nc:
+            curr = nc.pop(0)
+
+            while (len(nc) and
+                   isinstance(curr, SigmaOpBase) and
+                   isinstance(nc[0], SigmaOpBase) and
+                   curr.name == nc[0].name):
+
+                x = nc.pop(0)
+                y = _qsimplify_pauli_product(curr, x)
+                c1, nc1 = y.args_cnc()
+                curr = Mul(*nc1)
+                c = c + c1
+
+            nc_s.append(curr)
+
+        return Mul(*c) * Mul(*nc_s)
+
+    return e

venv/lib/python3.10/site-packages/sympy/physics/quantum/piab.py

@@ -0,0 +1,72 @@
+"""1D quantum particle in a box."""
+
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.sets.sets import Interval
+
+from sympy.physics.quantum.operator import HermitianOperator
+from sympy.physics.quantum.state import Ket, Bra
+from sympy.physics.quantum.constants import hbar
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.physics.quantum.hilbert import L2
+
+m = Symbol('m')
+L = Symbol('L')
+
+
+__all__ = [
+    'PIABHamiltonian',
+    'PIABKet',
+    'PIABBra'
+]
+
+
+class PIABHamiltonian(HermitianOperator):
+    """Particle in a box Hamiltonian operator."""
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return L2(Interval(S.NegativeInfinity, S.Infinity))
+
+    def _apply_operator_PIABKet(self, ket, **options):
+        n = ket.label[0]
+        return (n**2*pi**2*hbar**2)/(2*m*L**2)*ket
+
+
+class PIABKet(Ket):
+    """Particle in a box eigenket."""
+
+    @classmethod
+    def _eval_hilbert_space(cls, args):
+        return L2(Interval(S.NegativeInfinity, S.Infinity))
+
+    @classmethod
+    def dual_class(self):
+        return PIABBra
+
+    def _represent_default_basis(self, **options):
+        return self._represent_XOp(None, **options)
+
+    def _represent_XOp(self, basis, **options):
+        x = Symbol('x')
+        n = Symbol('n')
+        subs_info = options.get('subs', {})
+        return sqrt(2/L)*sin(n*pi*x/L).subs(subs_info)
+
+    def _eval_innerproduct_PIABBra(self, bra):
+        return KroneckerDelta(bra.label[0], self.label[0])
+
+
+class PIABBra(Bra):
+    """Particle in a box eigenbra."""
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return L2(Interval(S.NegativeInfinity, S.Infinity))
+
+    @classmethod
+    def dual_class(self):
+        return PIABKet

venv/lib/python3.10/site-packages/sympy/physics/quantum/qapply.py

@@ -0,0 +1,206 @@
+"""Logic for applying operators to states.
+
+Todo:
+* Sometimes the final result needs to be expanded, we should do this by hand.
+"""
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.sympify import sympify
+
+from sympy.physics.quantum.anticommutator import AntiCommutator
+from sympy.physics.quantum.commutator import Commutator
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.innerproduct import InnerProduct
+from sympy.physics.quantum.operator import OuterProduct, Operator
+from sympy.physics.quantum.state import State, KetBase, BraBase, Wavefunction
+from sympy.physics.quantum.tensorproduct import TensorProduct
+
+__all__ = [
+    'qapply'
+]
+
+
+#-----------------------------------------------------------------------------
+# Main code
+#-----------------------------------------------------------------------------
+
+def qapply(e, **options):
+    """Apply operators to states in a quantum expression.
+
+    Parameters
+    ==========
+
+    e : Expr
+        The expression containing operators and states. This expression tree
+        will be walked to find operators acting on states symbolically.
+    options : dict
+        A dict of key/value pairs that determine how the operator actions
+        are carried out.
+
+        The following options are valid:
+
+        * ``dagger``: try to apply Dagger operators to the left
+          (default: False).
+        * ``ip_doit``: call ``.doit()`` in inner products when they are
+          encountered (default: True).
+
+    Returns
+    =======
+
+    e : Expr
+        The original expression, but with the operators applied to states.
+
+    Examples
+    ========
+
+        >>> from sympy.physics.quantum import qapply, Ket, Bra
+        >>> b = Bra('b')
+        >>> k = Ket('k')
+        >>> A = k * b
+        >>> A
+        |k><b|
+        >>> qapply(A * b.dual / (b * b.dual))
+        |k>
+        >>> qapply(k.dual * A / (k.dual * k), dagger=True)
+        <b|
+        >>> qapply(k.dual * A / (k.dual * k))
+        <k|*|k><b|/<k|k>
+    """
+    from sympy.physics.quantum.density import Density
+
+    dagger = options.get('dagger', False)
+
+    if e == 0:
+        return S.Zero
+
+    # This may be a bit aggressive but ensures that everything gets expanded
+    # to its simplest form before trying to apply operators. This includes
+    # things like (A+B+C)*|a> and A*(|a>+|b>) and all Commutators and
+    # TensorProducts. The only problem with this is that if we can't apply
+    # all the Operators, we have just expanded everything.
+    # TODO: don't expand the scalars in front of each Mul.
+    e = e.expand(commutator=True, tensorproduct=True)
+
+    # If we just have a raw ket, return it.
+    if isinstance(e, KetBase):
+        return e
+
+    # We have an Add(a, b, c, ...) and compute
+    # Add(qapply(a), qapply(b), ...)
+    elif isinstance(e, Add):
+        result = 0
+        for arg in e.args:
+            result += qapply(arg, **options)
+        return result.expand()
+
+    # For a Density operator call qapply on its state
+    elif isinstance(e, Density):
+        new_args = [(qapply(state, **options), prob) for (state,
+                     prob) in e.args]
+        return Density(*new_args)
+
+    # For a raw TensorProduct, call qapply on its args.
+    elif isinstance(e, TensorProduct):
+        return TensorProduct(*[qapply(t, **options) for t in e.args])
+
+    # For a Pow, call qapply on its base.
+    elif isinstance(e, Pow):
+        return qapply(e.base, **options)**e.exp
+
+    # We have a Mul where there might be actual operators to apply to kets.
+    elif isinstance(e, Mul):
+        c_part, nc_part = e.args_cnc()
+        c_mul = Mul(*c_part)
+        nc_mul = Mul(*nc_part)
+        if isinstance(nc_mul, Mul):
+            result = c_mul*qapply_Mul(nc_mul, **options)
+        else:
+            result = c_mul*qapply(nc_mul, **options)
+        if result == e and dagger:
+            return Dagger(qapply_Mul(Dagger(e), **options))
+        else:
+            return result
+
+    # In all other cases (State, Operator, Pow, Commutator, InnerProduct,
+    # OuterProduct) we won't ever have operators to apply to kets.
+    else:
+        return e
+
+
+def qapply_Mul(e, **options):
+
+    ip_doit = options.get('ip_doit', True)
+
+    args = list(e.args)
+
+    # If we only have 0 or 1 args, we have nothing to do and return.
+    if len(args) <= 1 or not isinstance(e, Mul):
+        return e
+    rhs = args.pop()
+    lhs = args.pop()
+
+    # Make sure we have two non-commutative objects before proceeding.
+    if (not isinstance(rhs, Wavefunction) and sympify(rhs).is_commutative) or \
+            (not isinstance(lhs, Wavefunction) and sympify(lhs).is_commutative):
+        return e
+
+    # For a Pow with an integer exponent, apply one of them and reduce the
+    # exponent by one.
+    if isinstance(lhs, Pow) and lhs.exp.is_Integer:
+        args.append(lhs.base**(lhs.exp - 1))
+        lhs = lhs.base
+
+    # Pull OuterProduct apart
+    if isinstance(lhs, OuterProduct):
+        args.append(lhs.ket)
+        lhs = lhs.bra
+
+    # Call .doit() on Commutator/AntiCommutator.
+    if isinstance(lhs, (Commutator, AntiCommutator)):
+        comm = lhs.doit()
+        if isinstance(comm, Add):
+            return qapply(
+                e.func(*(args + [comm.args[0], rhs])) +
+                e.func(*(args + [comm.args[1], rhs])),
+                **options
+            )
+        else:
+            return qapply(e.func(*args)*comm*rhs, **options)
+
+    # Apply tensor products of operators to states
+    if isinstance(lhs, TensorProduct) and all(isinstance(arg, (Operator, State, Mul, Pow)) or arg == 1 for arg in lhs.args) and \
+            isinstance(rhs, TensorProduct) and all(isinstance(arg, (Operator, State, Mul, Pow)) or arg == 1 for arg in rhs.args) and \
+            len(lhs.args) == len(rhs.args):
+        result = TensorProduct(*[qapply(lhs.args[n]*rhs.args[n], **options) for n in range(len(lhs.args))]).expand(tensorproduct=True)
+        return qapply_Mul(e.func(*args), **options)*result
+
+    # Now try to actually apply the operator and build an inner product.
+    try:
+        result = lhs._apply_operator(rhs, **options)
+    except (NotImplementedError, AttributeError):
+        try:
+            result = rhs._apply_from_right_to(lhs, **options)
+        except (NotImplementedError, AttributeError):
+            if isinstance(lhs, BraBase) and isinstance(rhs, KetBase):
+                result = InnerProduct(lhs, rhs)
+                if ip_doit:
+                    result = result.doit()
+            else:
+                result = None
+
+    # TODO: I may need to expand before returning the final result.
+    if result == 0:
+        return S.Zero
+    elif result is None:
+        if len(args) == 0:
+            # We had two args to begin with so args=[].
+            return e
+        else:
+            return qapply_Mul(e.func(*(args + [lhs])), **options)*rhs
+    elif isinstance(result, InnerProduct):
+        return result*qapply_Mul(e.func(*args), **options)
+    else:  # result is a scalar times a Mul, Add or TensorProduct
+        return qapply(e.func(*args)*result, **options)

venv/lib/python3.10/site-packages/sympy/physics/quantum/qexpr.py

@@ -0,0 +1,413 @@
+from sympy.core.expr import Expr
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.matrices.dense import Matrix
+from sympy.printing.pretty.stringpict import prettyForm
+from sympy.core.containers import Tuple
+from sympy.utilities.iterables import is_sequence
+
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.matrixutils import (
+    numpy_ndarray, scipy_sparse_matrix,
+    to_sympy, to_numpy, to_scipy_sparse
+)
+
+__all__ = [
+    'QuantumError',
+    'QExpr'
+]
+
+
+#-----------------------------------------------------------------------------
+# Error handling
+#-----------------------------------------------------------------------------
+
+class QuantumError(Exception):
+    pass
+
+
+def _qsympify_sequence(seq):
+    """Convert elements of a sequence to standard form.
+
+    This is like sympify, but it performs special logic for arguments passed
+    to QExpr. The following conversions are done:
+
+    * (list, tuple, Tuple) => _qsympify_sequence each element and convert
+      sequence to a Tuple.
+    * basestring => Symbol
+    * Matrix => Matrix
+    * other => sympify
+
+    Strings are passed to Symbol, not sympify to make sure that variables like
+    'pi' are kept as Symbols, not the SymPy built-in number subclasses.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.qexpr import _qsympify_sequence
+    >>> _qsympify_sequence((1,2,[3,4,[1,]]))
+    (1, 2, (3, 4, (1,)))
+
+    """
+
+    return tuple(__qsympify_sequence_helper(seq))
+
+
+def __qsympify_sequence_helper(seq):
+    """
+       Helper function for _qsympify_sequence
+       This function does the actual work.
+    """
+    #base case. If not a list, do Sympification
+    if not is_sequence(seq):
+        if isinstance(seq, Matrix):
+            return seq
+        elif isinstance(seq, str):
+            return Symbol(seq)
+        else:
+            return sympify(seq)
+
+    # base condition, when seq is QExpr and also
+    # is iterable.
+    if isinstance(seq, QExpr):
+        return seq
+
+    #if list, recurse on each item in the list
+    result = [__qsympify_sequence_helper(item) for item in seq]
+
+    return Tuple(*result)
+
+
+#-----------------------------------------------------------------------------
+# Basic Quantum Expression from which all objects descend
+#-----------------------------------------------------------------------------
+
+class QExpr(Expr):
+    """A base class for all quantum object like operators and states."""
+
+    # In sympy, slots are for instance attributes that are computed
+    # dynamically by the __new__ method. They are not part of args, but they
+    # derive from args.
+
+    # The Hilbert space a quantum Object belongs to.
+    __slots__ = ('hilbert_space', )
+
+    is_commutative = False
+
+    # The separator used in printing the label.
+    _label_separator = ''
+
+    @property
+    def free_symbols(self):
+        return {self}
+
+    def __new__(cls, *args, **kwargs):
+        """Construct a new quantum object.
+
+        Parameters
+        ==========
+
+        args : tuple
+            The list of numbers or parameters that uniquely specify the
+            quantum object. For a state, this will be its symbol or its
+            set of quantum numbers.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.quantum.qexpr import QExpr
+        >>> q = QExpr(0)
+        >>> q
+        0
+        >>> q.label
+        (0,)
+        >>> q.hilbert_space
+        H
+        >>> q.args
+        (0,)
+        >>> q.is_commutative
+        False
+        """
+
+        # First compute args and call Expr.__new__ to create the instance
+        args = cls._eval_args(args, **kwargs)
+        if len(args) == 0:
+            args = cls._eval_args(tuple(cls.default_args()), **kwargs)
+        inst = Expr.__new__(cls, *args)
+        # Now set the slots on the instance
+        inst.hilbert_space = cls._eval_hilbert_space(args)
+        return inst
+
+    @classmethod
+    def _new_rawargs(cls, hilbert_space, *args, **old_assumptions):
+        """Create new instance of this class with hilbert_space and args.
+
+        This is used to bypass the more complex logic in the ``__new__``
+        method in cases where you already have the exact ``hilbert_space``
+        and ``args``. This should be used when you are positive these
+        arguments are valid, in their final, proper form and want to optimize
+        the creation of the object.
+        """
+
+        obj = Expr.__new__(cls, *args, **old_assumptions)
+        obj.hilbert_space = hilbert_space
+        return obj
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def label(self):
+        """The label is the unique set of identifiers for the object.
+
+        Usually, this will include all of the information about the state
+        *except* the time (in the case of time-dependent objects).
+
+        This must be a tuple, rather than a Tuple.
+        """
+        if len(self.args) == 0:  # If there is no label specified, return the default
+            return self._eval_args(list(self.default_args()))
+        else:
+            return self.args
+
+    @property
+    def is_symbolic(self):
+        return True
+
+    @classmethod
+    def default_args(self):
+        """If no arguments are specified, then this will return a default set
+        of arguments to be run through the constructor.
+
+        NOTE: Any classes that override this MUST return a tuple of arguments.
+        Should be overridden by subclasses to specify the default arguments for kets and operators
+        """
+        raise NotImplementedError("No default arguments for this class!")
+
+    #-------------------------------------------------------------------------
+    # _eval_* methods
+    #-------------------------------------------------------------------------
+
+    def _eval_adjoint(self):
+        obj = Expr._eval_adjoint(self)
+        if obj is None:
+            obj = Expr.__new__(Dagger, self)
+        if isinstance(obj, QExpr):
+            obj.hilbert_space = self.hilbert_space
+        return obj
+
+    @classmethod
+    def _eval_args(cls, args):
+        """Process the args passed to the __new__ method.
+
+        This simply runs args through _qsympify_sequence.
+        """
+        return _qsympify_sequence(args)
+
+    @classmethod
+    def _eval_hilbert_space(cls, args):
+        """Compute the Hilbert space instance from the args.
+        """
+        from sympy.physics.quantum.hilbert import HilbertSpace
+        return HilbertSpace()
+
+    #-------------------------------------------------------------------------
+    # Printing
+    #-------------------------------------------------------------------------
+
+    # Utilities for printing: these operate on raw SymPy objects
+
+    def _print_sequence(self, seq, sep, printer, *args):
+        result = []
+        for item in seq:
+            result.append(printer._print(item, *args))
+        return sep.join(result)
+
+    def _print_sequence_pretty(self, seq, sep, printer, *args):
+        pform = printer._print(seq[0], *args)
+        for item in seq[1:]:
+            pform = prettyForm(*pform.right(sep))
+            pform = prettyForm(*pform.right(printer._print(item, *args)))
+        return pform
+
+    # Utilities for printing: these operate prettyForm objects
+
+    def _print_subscript_pretty(self, a, b):
+        top = prettyForm(*b.left(' '*a.width()))
+        bot = prettyForm(*a.right(' '*b.width()))
+        return prettyForm(binding=prettyForm.POW, *bot.below(top))
+
+    def _print_superscript_pretty(self, a, b):
+        return a**b
+
+    def _print_parens_pretty(self, pform, left='(', right=')'):
+        return prettyForm(*pform.parens(left=left, right=right))
+
+    # Printing of labels (i.e. args)
+
+    def _print_label(self, printer, *args):
+        """Prints the label of the QExpr
+
+        This method prints self.label, using self._label_separator to separate
+        the elements. This method should not be overridden, instead, override
+        _print_contents to change printing behavior.
+        """
+        return self._print_sequence(
+            self.label, self._label_separator, printer, *args
+        )
+
+    def _print_label_repr(self, printer, *args):
+        return self._print_sequence(
+            self.label, ',', printer, *args
+        )
+
+    def _print_label_pretty(self, printer, *args):
+        return self._print_sequence_pretty(
+            self.label, self._label_separator, printer, *args
+        )
+
+    def _print_label_latex(self, printer, *args):
+        return self._print_sequence(
+            self.label, self._label_separator, printer, *args
+        )
+
+    # Printing of contents (default to label)
+
+    def _print_contents(self, printer, *args):
+        """Printer for contents of QExpr
+
+        Handles the printing of any unique identifying contents of a QExpr to
+        print as its contents, such as any variables or quantum numbers. The
+        default is to print the label, which is almost always the args. This
+        should not include printing of any brackets or parentheses.
+        """
+        return self._print_label(printer, *args)
+
+    def _print_contents_pretty(self, printer, *args):
+        return self._print_label_pretty(printer, *args)
+
+    def _print_contents_latex(self, printer, *args):
+        return self._print_label_latex(printer, *args)
+
+    # Main printing methods
+
+    def _sympystr(self, printer, *args):
+        """Default printing behavior of QExpr objects
+
+        Handles the default printing of a QExpr. To add other things to the
+        printing of the object, such as an operator name to operators or
+        brackets to states, the class should override the _print/_pretty/_latex
+        functions directly and make calls to _print_contents where appropriate.
+        This allows things like InnerProduct to easily control its printing the
+        printing of contents.
+        """
+        return self._print_contents(printer, *args)
+
+    def _sympyrepr(self, printer, *args):
+        classname = self.__class__.__name__
+        label = self._print_label_repr(printer, *args)
+        return '%s(%s)' % (classname, label)
+
+    def _pretty(self, printer, *args):
+        pform = self._print_contents_pretty(printer, *args)
+        return pform
+
+    def _latex(self, printer, *args):
+        return self._print_contents_latex(printer, *args)
+
+    #-------------------------------------------------------------------------
+    # Represent
+    #-------------------------------------------------------------------------
+
+    def _represent_default_basis(self, **options):
+        raise NotImplementedError('This object does not have a default basis')
+
+    def _represent(self, *, basis=None, **options):
+        """Represent this object in a given basis.
+
+        This method dispatches to the actual methods that perform the
+        representation. Subclases of QExpr should define various methods to
+        determine how the object will be represented in various bases. The
+        format of these methods is::
+
+            def _represent_BasisName(self, basis, **options):
+
+        Thus to define how a quantum object is represented in the basis of
+        the operator Position, you would define::
+
+            def _represent_Position(self, basis, **options):
+
+        Usually, basis object will be instances of Operator subclasses, but
+        there is a chance we will relax this in the future to accommodate other
+        types of basis sets that are not associated with an operator.
+
+        If the ``format`` option is given it can be ("sympy", "numpy",
+        "scipy.sparse"). This will ensure that any matrices that result from
+        representing the object are returned in the appropriate matrix format.
+
+        Parameters
+        ==========
+
+        basis : Operator
+            The Operator whose basis functions will be used as the basis for
+            representation.
+        options : dict
+            A dictionary of key/value pairs that give options and hints for
+            the representation, such as the number of basis functions to
+            be used.
+        """
+        if basis is None:
+            result = self._represent_default_basis(**options)
+        else:
+            result = dispatch_method(self, '_represent', basis, **options)
+
+        # If we get a matrix representation, convert it to the right format.
+        format = options.get('format', 'sympy')
+        result = self._format_represent(result, format)
+        return result
+
+    def _format_represent(self, result, format):
+        if format == 'sympy' and not isinstance(result, Matrix):
+            return to_sympy(result)
+        elif format == 'numpy' and not isinstance(result, numpy_ndarray):
+            return to_numpy(result)
+        elif format == 'scipy.sparse' and \
+                not isinstance(result, scipy_sparse_matrix):
+            return to_scipy_sparse(result)
+
+        return result
+
+
+def split_commutative_parts(e):
+    """Split into commutative and non-commutative parts."""
+    c_part, nc_part = e.args_cnc()
+    c_part = list(c_part)
+    return c_part, nc_part
+
+
+def split_qexpr_parts(e):
+    """Split an expression into Expr and noncommutative QExpr parts."""
+    expr_part = []
+    qexpr_part = []
+    for arg in e.args:
+        if not isinstance(arg, QExpr):
+            expr_part.append(arg)
+        else:
+            qexpr_part.append(arg)
+    return expr_part, qexpr_part
+
+
+def dispatch_method(self, basename, arg, **options):
+    """Dispatch a method to the proper handlers."""
+    method_name = '%s_%s' % (basename, arg.__class__.__name__)
+    if hasattr(self, method_name):
+        f = getattr(self, method_name)
+        # This can raise and we will allow it to propagate.
+        result = f(arg, **options)
+        if result is not None:
+            return result
+    raise NotImplementedError(
+        "%s.%s cannot handle: %r" %
+        (self.__class__.__name__, basename, arg)
+    )

venv/lib/python3.10/site-packages/sympy/physics/quantum/qubit.py

@@ -0,0 +1,811 @@
+"""Qubits for quantum computing.
+
+Todo:
+* Finish implementing measurement logic. This should include POVM.
+* Update docstrings.
+* Update tests.
+"""
+
+
+import math
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.exponential import log
+from sympy.core.basic import _sympify
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.matrices import Matrix, zeros
+from sympy.printing.pretty.stringpict import prettyForm
+
+from sympy.physics.quantum.hilbert import ComplexSpace
+from sympy.physics.quantum.state import Ket, Bra, State
+
+from sympy.physics.quantum.qexpr import QuantumError
+from sympy.physics.quantum.represent import represent
+from sympy.physics.quantum.matrixutils import (
+    numpy_ndarray, scipy_sparse_matrix
+)
+from mpmath.libmp.libintmath import bitcount
+
+__all__ = [
+    'Qubit',
+    'QubitBra',
+    'IntQubit',
+    'IntQubitBra',
+    'qubit_to_matrix',
+    'matrix_to_qubit',
+    'matrix_to_density',
+    'measure_all',
+    'measure_partial',
+    'measure_partial_oneshot',
+    'measure_all_oneshot'
+]
+
+#-----------------------------------------------------------------------------
+# Qubit Classes
+#-----------------------------------------------------------------------------
+
+
+class QubitState(State):
+    """Base class for Qubit and QubitBra."""
+
+    #-------------------------------------------------------------------------
+    # Initialization/creation
+    #-------------------------------------------------------------------------
+
+    @classmethod
+    def _eval_args(cls, args):
+        # If we are passed a QubitState or subclass, we just take its qubit
+        # values directly.
+        if len(args) == 1 and isinstance(args[0], QubitState):
+            return args[0].qubit_values
+
+        # Turn strings into tuple of strings
+        if len(args) == 1 and isinstance(args[0], str):
+            args = tuple( S.Zero if qb == "0" else S.One for qb in args[0])
+        else:
+            args = tuple( S.Zero if qb == "0" else S.One if qb == "1" else qb for qb in args)
+        args = tuple(_sympify(arg) for arg in args)
+
+        # Validate input (must have 0 or 1 input)
+        for element in args:
+            if element not in (S.Zero, S.One):
+                raise ValueError(
+                    "Qubit values must be 0 or 1, got: %r" % element)
+        return args
+
+    @classmethod
+    def _eval_hilbert_space(cls, args):
+        return ComplexSpace(2)**len(args)
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def dimension(self):
+        """The number of Qubits in the state."""
+        return len(self.qubit_values)
+
+    @property
+    def nqubits(self):
+        return self.dimension
+
+    @property
+    def qubit_values(self):
+        """Returns the values of the qubits as a tuple."""
+        return self.label
+
+    #-------------------------------------------------------------------------
+    # Special methods
+    #-------------------------------------------------------------------------
+
+    def __len__(self):
+        return self.dimension
+
+    def __getitem__(self, bit):
+        return self.qubit_values[int(self.dimension - bit - 1)]
+
+    #-------------------------------------------------------------------------
+    # Utility methods
+    #-------------------------------------------------------------------------
+
+    def flip(self, *bits):
+        """Flip the bit(s) given."""
+        newargs = list(self.qubit_values)
+        for i in bits:
+            bit = int(self.dimension - i - 1)
+            if newargs[bit] == 1:
+                newargs[bit] = 0
+            else:
+                newargs[bit] = 1
+        return self.__class__(*tuple(newargs))
+
+
+class Qubit(QubitState, Ket):
+    """A multi-qubit ket in the computational (z) basis.
+
+    We use the normal convention that the least significant qubit is on the
+    right, so ``|00001>`` has a 1 in the least significant qubit.
+
+    Parameters
+    ==========
+
+    values : list, str
+        The qubit values as a list of ints ([0,0,0,1,1,]) or a string ('011').
+
+    Examples
+    ========
+
+    Create a qubit in a couple of different ways and look at their attributes:
+
+        >>> from sympy.physics.quantum.qubit import Qubit
+        >>> Qubit(0,0,0)
+        |000>
+        >>> q = Qubit('0101')
+        >>> q
+        |0101>
+
+        >>> q.nqubits
+        4
+        >>> len(q)
+        4
+        >>> q.dimension
+        4
+        >>> q.qubit_values
+        (0, 1, 0, 1)
+
+    We can flip the value of an individual qubit:
+
+        >>> q.flip(1)
+        |0111>
+
+    We can take the dagger of a Qubit to get a bra:
+
+        >>> from sympy.physics.quantum.dagger import Dagger
+        >>> Dagger(q)
+        <0101|
+        >>> type(Dagger(q))
+        <class 'sympy.physics.quantum.qubit.QubitBra'>
+
+    Inner products work as expected:
+
+        >>> ip = Dagger(q)*q
+        >>> ip
+        <0101|0101>
+        >>> ip.doit()
+        1
+    """
+
+    @classmethod
+    def dual_class(self):
+        return QubitBra
+
+    def _eval_innerproduct_QubitBra(self, bra, **hints):
+        if self.label == bra.label:
+            return S.One
+        else:
+            return S.Zero
+
+    def _represent_default_basis(self, **options):
+        return self._represent_ZGate(None, **options)
+
+    def _represent_ZGate(self, basis, **options):
+        """Represent this qubits in the computational basis (ZGate).
+        """
+        _format = options.get('format', 'sympy')
+        n = 1
+        definite_state = 0
+        for it in reversed(self.qubit_values):
+            definite_state += n*it
+            n = n*2
+        result = [0]*(2**self.dimension)
+        result[int(definite_state)] = 1
+        if _format == 'sympy':
+            return Matrix(result)
+        elif _format == 'numpy':
+            import numpy as np
+            return np.array(result, dtype='complex').transpose()
+        elif _format == 'scipy.sparse':
+            from scipy import sparse
+            return sparse.csr_matrix(result, dtype='complex').transpose()
+
+    def _eval_trace(self, bra, **kwargs):
+        indices = kwargs.get('indices', [])
+
+        #sort index list to begin trace from most-significant
+        #qubit
+        sorted_idx = list(indices)
+        if len(sorted_idx) == 0:
+            sorted_idx = list(range(0, self.nqubits))
+        sorted_idx.sort()
+
+        #trace out for each of index
+        new_mat = self*bra
+        for i in range(len(sorted_idx) - 1, -1, -1):
+            # start from tracing out from leftmost qubit
+            new_mat = self._reduced_density(new_mat, int(sorted_idx[i]))
+
+        if (len(sorted_idx) == self.nqubits):
+            #in case full trace was requested
+            return new_mat[0]
+        else:
+            return matrix_to_density(new_mat)
+
+    def _reduced_density(self, matrix, qubit, **options):
+        """Compute the reduced density matrix by tracing out one qubit.
+           The qubit argument should be of type Python int, since it is used
+           in bit operations
+        """
+        def find_index_that_is_projected(j, k, qubit):
+            bit_mask = 2**qubit - 1
+            return ((j >> qubit) << (1 + qubit)) + (j & bit_mask) + (k << qubit)
+
+        old_matrix = represent(matrix, **options)
+        old_size = old_matrix.cols
+        #we expect the old_size to be even
+        new_size = old_size//2
+        new_matrix = Matrix().zeros(new_size)
+
+        for i in range(new_size):
+            for j in range(new_size):
+                for k in range(2):
+                    col = find_index_that_is_projected(j, k, qubit)
+                    row = find_index_that_is_projected(i, k, qubit)
+                    new_matrix[i, j] += old_matrix[row, col]
+
+        return new_matrix
+
+
+class QubitBra(QubitState, Bra):
+    """A multi-qubit bra in the computational (z) basis.
+
+    We use the normal convention that the least significant qubit is on the
+    right, so ``|00001>`` has a 1 in the least significant qubit.
+
+    Parameters
+    ==========
+
+    values : list, str
+        The qubit values as a list of ints ([0,0,0,1,1,]) or a string ('011').
+
+    See also
+    ========
+
+    Qubit: Examples using qubits
+
+    """
+    @classmethod
+    def dual_class(self):
+        return Qubit
+
+
+class IntQubitState(QubitState):
+    """A base class for qubits that work with binary representations."""
+
+    @classmethod
+    def _eval_args(cls, args, nqubits=None):
+        # The case of a QubitState instance
+        if len(args) == 1 and isinstance(args[0], QubitState):
+            return QubitState._eval_args(args)
+        # otherwise, args should be integer
+        elif not all(isinstance(a, (int, Integer)) for a in args):
+            raise ValueError('values must be integers, got (%s)' % (tuple(type(a) for a in args),))
+        # use nqubits if specified
+        if nqubits is not None:
+            if not isinstance(nqubits, (int, Integer)):
+                raise ValueError('nqubits must be an integer, got (%s)' % type(nqubits))
+            if len(args) != 1:
+                raise ValueError(
+                    'too many positional arguments (%s). should be (number, nqubits=n)' % (args,))
+            return cls._eval_args_with_nqubits(args[0], nqubits)
+        # For a single argument, we construct the binary representation of
+        # that integer with the minimal number of bits.
+        if len(args) == 1 and args[0] > 1:
+            #rvalues is the minimum number of bits needed to express the number
+            rvalues = reversed(range(bitcount(abs(args[0]))))
+            qubit_values = [(args[0] >> i) & 1 for i in rvalues]
+            return QubitState._eval_args(qubit_values)
+        # For two numbers, the second number is the number of bits
+        # on which it is expressed, so IntQubit(0,5) == |00000>.
+        elif len(args) == 2 and args[1] > 1:
+            return cls._eval_args_with_nqubits(args[0], args[1])
+        else:
+            return QubitState._eval_args(args)
+
+    @classmethod
+    def _eval_args_with_nqubits(cls, number, nqubits):
+        need = bitcount(abs(number))
+        if nqubits < need:
+            raise ValueError(
+                'cannot represent %s with %s bits' % (number, nqubits))
+        qubit_values = [(number >> i) & 1 for i in reversed(range(nqubits))]
+        return QubitState._eval_args(qubit_values)
+
+    def as_int(self):
+        """Return the numerical value of the qubit."""
+        number = 0
+        n = 1
+        for i in reversed(self.qubit_values):
+            number += n*i
+            n = n << 1
+        return number
+
+    def _print_label(self, printer, *args):
+        return str(self.as_int())
+
+    def _print_label_pretty(self, printer, *args):
+        label = self._print_label(printer, *args)
+        return prettyForm(label)
+
+    _print_label_repr = _print_label
+    _print_label_latex = _print_label
+
+
+class IntQubit(IntQubitState, Qubit):
+    """A qubit ket that store integers as binary numbers in qubit values.
+
+    The differences between this class and ``Qubit`` are:
+
+    * The form of the constructor.
+    * The qubit values are printed as their corresponding integer, rather
+      than the raw qubit values. The internal storage format of the qubit
+      values in the same as ``Qubit``.
+
+    Parameters
+    ==========
+
+    values : int, tuple
+        If a single argument, the integer we want to represent in the qubit
+        values. This integer will be represented using the fewest possible
+        number of qubits.
+        If a pair of integers and the second value is more than one, the first
+        integer gives the integer to represent in binary form and the second
+        integer gives the number of qubits to use.
+        List of zeros and ones is also accepted to generate qubit by bit pattern.
+
+    nqubits : int
+        The integer that represents the number of qubits.
+        This number should be passed with keyword ``nqubits=N``.
+        You can use this in order to avoid ambiguity of Qubit-style tuple of bits.
+        Please see the example below for more details.
+
+    Examples
+    ========
+
+    Create a qubit for the integer 5:
+
+        >>> from sympy.physics.quantum.qubit import IntQubit
+        >>> from sympy.physics.quantum.qubit import Qubit
+        >>> q = IntQubit(5)
+        >>> q
+        |5>
+
+    We can also create an ``IntQubit`` by passing a ``Qubit`` instance.
+
+        >>> q = IntQubit(Qubit('101'))
+        >>> q
+        |5>
+        >>> q.as_int()
+        5
+        >>> q.nqubits
+        3
+        >>> q.qubit_values
+        (1, 0, 1)
+
+    We can go back to the regular qubit form.
+
+        >>> Qubit(q)
+        |101>
+
+    Please note that ``IntQubit`` also accepts a ``Qubit``-style list of bits.
+    So, the code below yields qubits 3, not a single bit ``1``.
+
+        >>> IntQubit(1, 1)
+        |3>
+
+    To avoid ambiguity, use ``nqubits`` parameter.
+    Use of this keyword is recommended especially when you provide the values by variables.
+
+        >>> IntQubit(1, nqubits=1)
+        |1>
+        >>> a = 1
+        >>> IntQubit(a, nqubits=1)
+        |1>
+    """
+    @classmethod
+    def dual_class(self):
+        return IntQubitBra
+
+    def _eval_innerproduct_IntQubitBra(self, bra, **hints):
+        return Qubit._eval_innerproduct_QubitBra(self, bra)
+
+class IntQubitBra(IntQubitState, QubitBra):
+    """A qubit bra that store integers as binary numbers in qubit values."""
+
+    @classmethod
+    def dual_class(self):
+        return IntQubit
+
+
+#-----------------------------------------------------------------------------
+# Qubit <---> Matrix conversion functions
+#-----------------------------------------------------------------------------
+
+
+def matrix_to_qubit(matrix):
+    """Convert from the matrix repr. to a sum of Qubit objects.
+
+    Parameters
+    ----------
+    matrix : Matrix, numpy.matrix, scipy.sparse
+        The matrix to build the Qubit representation of. This works with
+        SymPy matrices, numpy matrices and scipy.sparse sparse matrices.
+
+    Examples
+    ========
+
+    Represent a state and then go back to its qubit form:
+
+        >>> from sympy.physics.quantum.qubit import matrix_to_qubit, Qubit
+        >>> from sympy.physics.quantum.represent import represent
+        >>> q = Qubit('01')
+        >>> matrix_to_qubit(represent(q))
+        |01>
+    """
+    # Determine the format based on the type of the input matrix
+    format = 'sympy'
+    if isinstance(matrix, numpy_ndarray):
+        format = 'numpy'
+    if isinstance(matrix, scipy_sparse_matrix):
+        format = 'scipy.sparse'
+
+    # Make sure it is of correct dimensions for a Qubit-matrix representation.
+    # This logic should work with sympy, numpy or scipy.sparse matrices.
+    if matrix.shape[0] == 1:
+        mlistlen = matrix.shape[1]
+        nqubits = log(mlistlen, 2)
+        ket = False
+        cls = QubitBra
+    elif matrix.shape[1] == 1:
+        mlistlen = matrix.shape[0]
+        nqubits = log(mlistlen, 2)
+        ket = True
+        cls = Qubit
+    else:
+        raise QuantumError(
+            'Matrix must be a row/column vector, got %r' % matrix
+        )
+    if not isinstance(nqubits, Integer):
+        raise QuantumError('Matrix must be a row/column vector of size '
+                           '2**nqubits, got: %r' % matrix)
+    # Go through each item in matrix, if element is non-zero, make it into a
+    # Qubit item times the element.
+    result = 0
+    for i in range(mlistlen):
+        if ket:
+            element = matrix[i, 0]
+        else:
+            element = matrix[0, i]
+        if format in ('numpy', 'scipy.sparse'):
+            element = complex(element)
+        if element != 0.0:
+            # Form Qubit array; 0 in bit-locations where i is 0, 1 in
+            # bit-locations where i is 1
+            qubit_array = [int(i & (1 << x) != 0) for x in range(nqubits)]
+            qubit_array.reverse()
+            result = result + element*cls(*qubit_array)
+
+    # If SymPy simplified by pulling out a constant coefficient, undo that.
+    if isinstance(result, (Mul, Add, Pow)):
+        result = result.expand()
+
+    return result
+
+
+def matrix_to_density(mat):
+    """
+    Works by finding the eigenvectors and eigenvalues of the matrix.
+    We know we can decompose rho by doing:
+    sum(EigenVal*|Eigenvect><Eigenvect|)
+    """
+    from sympy.physics.quantum.density import Density
+    eigen = mat.eigenvects()
+    args = [[matrix_to_qubit(Matrix(
+        [vector, ])), x[0]] for x in eigen for vector in x[2] if x[0] != 0]
+    if (len(args) == 0):
+        return S.Zero
+    else:
+        return Density(*args)
+
+
+def qubit_to_matrix(qubit, format='sympy'):
+    """Converts an Add/Mul of Qubit objects into it's matrix representation
+
+    This function is the inverse of ``matrix_to_qubit`` and is a shorthand
+    for ``represent(qubit)``.
+    """
+    return represent(qubit, format=format)
+
+
+#-----------------------------------------------------------------------------
+# Measurement
+#-----------------------------------------------------------------------------
+
+
+def measure_all(qubit, format='sympy', normalize=True):
+    """Perform an ensemble measurement of all qubits.
+
+    Parameters
+    ==========
+
+    qubit : Qubit, Add
+        The qubit to measure. This can be any Qubit or a linear combination
+        of them.
+    format : str
+        The format of the intermediate matrices to use. Possible values are
+        ('sympy','numpy','scipy.sparse'). Currently only 'sympy' is
+        implemented.
+
+    Returns
+    =======
+
+    result : list
+        A list that consists of primitive states and their probabilities.
+
+    Examples
+    ========
+
+        >>> from sympy.physics.quantum.qubit import Qubit, measure_all
+        >>> from sympy.physics.quantum.gate import H
+        >>> from sympy.physics.quantum.qapply import qapply
+
+        >>> c = H(0)*H(1)*Qubit('00')
+        >>> c
+        H(0)*H(1)*|00>
+        >>> q = qapply(c)
+        >>> measure_all(q)
+        [(|00>, 1/4), (|01>, 1/4), (|10>, 1/4), (|11>, 1/4)]
+    """
+    m = qubit_to_matrix(qubit, format)
+
+    if format == 'sympy':
+        results = []
+
+        if normalize:
+            m = m.normalized()
+
+        size = max(m.shape)  # Max of shape to account for bra or ket
+        nqubits = int(math.log(size)/math.log(2))
+        for i in range(size):
+            if m[i] != 0.0:
+                results.append(
+                    (Qubit(IntQubit(i, nqubits=nqubits)), m[i]*conjugate(m[i]))
+                )
+        return results
+    else:
+        raise NotImplementedError(
+            "This function cannot handle non-SymPy matrix formats yet"
+        )
+
+
+def measure_partial(qubit, bits, format='sympy', normalize=True):
+    """Perform a partial ensemble measure on the specified qubits.
+
+    Parameters
+    ==========
+
+    qubits : Qubit
+        The qubit to measure.  This can be any Qubit or a linear combination
+        of them.
+    bits : tuple
+        The qubits to measure.
+    format : str
+        The format of the intermediate matrices to use. Possible values are
+        ('sympy','numpy','scipy.sparse'). Currently only 'sympy' is
+        implemented.
+
+    Returns
+    =======
+
+    result : list
+        A list that consists of primitive states and their probabilities.
+
+    Examples
+    ========
+
+        >>> from sympy.physics.quantum.qubit import Qubit, measure_partial
+        >>> from sympy.physics.quantum.gate import H
+        >>> from sympy.physics.quantum.qapply import qapply
+
+        >>> c = H(0)*H(1)*Qubit('00')
+        >>> c
+        H(0)*H(1)*|00>
+        >>> q = qapply(c)
+        >>> measure_partial(q, (0,))
+        [(sqrt(2)*|00>/2 + sqrt(2)*|10>/2, 1/2), (sqrt(2)*|01>/2 + sqrt(2)*|11>/2, 1/2)]
+    """
+    m = qubit_to_matrix(qubit, format)
+
+    if isinstance(bits, (SYMPY_INTS, Integer)):
+        bits = (int(bits),)
+
+    if format == 'sympy':
+        if normalize:
+            m = m.normalized()
+
+        possible_outcomes = _get_possible_outcomes(m, bits)
+
+        # Form output from function.
+        output = []
+        for outcome in possible_outcomes:
+            # Calculate probability of finding the specified bits with
+            # given values.
+            prob_of_outcome = 0
+            prob_of_outcome += (outcome.H*outcome)[0]
+
+            # If the output has a chance, append it to output with found
+            # probability.
+            if prob_of_outcome != 0:
+                if normalize:
+                    next_matrix = matrix_to_qubit(outcome.normalized())
+                else:
+                    next_matrix = matrix_to_qubit(outcome)
+
+                output.append((
+                    next_matrix,
+                    prob_of_outcome
+                ))
+
+        return output
+    else:
+        raise NotImplementedError(
+            "This function cannot handle non-SymPy matrix formats yet"
+        )
+
+
+def measure_partial_oneshot(qubit, bits, format='sympy'):
+    """Perform a partial oneshot measurement on the specified qubits.
+
+    A oneshot measurement is equivalent to performing a measurement on a
+    quantum system. This type of measurement does not return the probabilities
+    like an ensemble measurement does, but rather returns *one* of the
+    possible resulting states. The exact state that is returned is determined
+    by picking a state randomly according to the ensemble probabilities.
+
+    Parameters
+    ----------
+    qubits : Qubit
+        The qubit to measure.  This can be any Qubit or a linear combination
+        of them.
+    bits : tuple
+        The qubits to measure.
+    format : str
+        The format of the intermediate matrices to use. Possible values are
+        ('sympy','numpy','scipy.sparse'). Currently only 'sympy' is
+        implemented.
+
+    Returns
+    -------
+    result : Qubit
+        The qubit that the system collapsed to upon measurement.
+    """
+    import random
+    m = qubit_to_matrix(qubit, format)
+
+    if format == 'sympy':
+        m = m.normalized()
+        possible_outcomes = _get_possible_outcomes(m, bits)
+
+        # Form output from function
+        random_number = random.random()
+        total_prob = 0
+        for outcome in possible_outcomes:
+            # Calculate probability of finding the specified bits
+            # with given values
+            total_prob += (outcome.H*outcome)[0]
+            if total_prob >= random_number:
+                return matrix_to_qubit(outcome.normalized())
+    else:
+        raise NotImplementedError(
+            "This function cannot handle non-SymPy matrix formats yet"
+        )
+
+
+def _get_possible_outcomes(m, bits):
+    """Get the possible states that can be produced in a measurement.
+
+    Parameters
+    ----------
+    m : Matrix
+        The matrix representing the state of the system.
+    bits : tuple, list
+        Which bits will be measured.
+
+    Returns
+    -------
+    result : list
+        The list of possible states which can occur given this measurement.
+        These are un-normalized so we can derive the probability of finding
+        this state by taking the inner product with itself
+    """
+
+    # This is filled with loads of dirty binary tricks...You have been warned
+
+    size = max(m.shape)  # Max of shape to account for bra or ket
+    nqubits = int(math.log(size, 2) + .1)  # Number of qubits possible
+
+    # Make the output states and put in output_matrices, nothing in them now.
+    # Each state will represent a possible outcome of the measurement
+    # Thus, output_matrices[0] is the matrix which we get when all measured
+    # bits return 0. and output_matrices[1] is the matrix for only the 0th
+    # bit being true
+    output_matrices = []
+    for i in range(1 << len(bits)):
+        output_matrices.append(zeros(2**nqubits, 1))
+
+    # Bitmasks will help sort how to determine possible outcomes.
+    # When the bit mask is and-ed with a matrix-index,
+    # it will determine which state that index belongs to
+    bit_masks = []
+    for bit in bits:
+        bit_masks.append(1 << bit)
+
+    # Make possible outcome states
+    for i in range(2**nqubits):
+        trueness = 0  # This tells us to which output_matrix this value belongs
+        # Find trueness
+        for j in range(len(bit_masks)):
+            if i & bit_masks[j]:
+                trueness += j + 1
+        # Put the value in the correct output matrix
+        output_matrices[trueness][i] = m[i]
+    return output_matrices
+
+
+def measure_all_oneshot(qubit, format='sympy'):
+    """Perform a oneshot ensemble measurement on all qubits.
+
+    A oneshot measurement is equivalent to performing a measurement on a
+    quantum system. This type of measurement does not return the probabilities
+    like an ensemble measurement does, but rather returns *one* of the
+    possible resulting states. The exact state that is returned is determined
+    by picking a state randomly according to the ensemble probabilities.
+
+    Parameters
+    ----------
+    qubits : Qubit
+        The qubit to measure.  This can be any Qubit or a linear combination
+        of them.
+    format : str
+        The format of the intermediate matrices to use. Possible values are
+        ('sympy','numpy','scipy.sparse'). Currently only 'sympy' is
+        implemented.
+
+    Returns
+    -------
+    result : Qubit
+        The qubit that the system collapsed to upon measurement.
+    """
+    import random
+    m = qubit_to_matrix(qubit)
+
+    if format == 'sympy':
+        m = m.normalized()
+        random_number = random.random()
+        total = 0
+        result = 0
+        for i in m:
+            total += i*i.conjugate()
+            if total > random_number:
+                break
+            result += 1
+        return Qubit(IntQubit(result, int(math.log(max(m.shape), 2) + .1)))
+    else:
+        raise NotImplementedError(
+            "This function cannot handle non-SymPy matrix formats yet"
+        )

venv/lib/python3.10/site-packages/sympy/physics/quantum/represent.py

@@ -0,0 +1,574 @@
+"""Logic for representing operators in state in various bases.
+
+TODO:
+
+* Get represent working with continuous hilbert spaces.
+* Document default basis functionality.
+"""
+
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.mul import Mul
+from sympy.core.numbers import I
+from sympy.core.power import Pow
+from sympy.integrals.integrals import integrate
+from sympy.physics.quantum.dagger import Dagger
+from sympy.physics.quantum.commutator import Commutator
+from sympy.physics.quantum.anticommutator import AntiCommutator
+from sympy.physics.quantum.innerproduct import InnerProduct
+from sympy.physics.quantum.qexpr import QExpr
+from sympy.physics.quantum.tensorproduct import TensorProduct
+from sympy.physics.quantum.matrixutils import flatten_scalar
+from sympy.physics.quantum.state import KetBase, BraBase, StateBase
+from sympy.physics.quantum.operator import Operator, OuterProduct
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.operatorset import operators_to_state, state_to_operators
+
+__all__ = [
+    'represent',
+    'rep_innerproduct',
+    'rep_expectation',
+    'integrate_result',
+    'get_basis',
+    'enumerate_states'
+]
+
+#-----------------------------------------------------------------------------
+# Represent
+#-----------------------------------------------------------------------------
+
+
+def _sympy_to_scalar(e):
+    """Convert from a SymPy scalar to a Python scalar."""
+    if isinstance(e, Expr):
+        if e.is_Integer:
+            return int(e)
+        elif e.is_Float:
+            return float(e)
+        elif e.is_Rational:
+            return float(e)
+        elif e.is_Number or e.is_NumberSymbol or e == I:
+            return complex(e)
+    raise TypeError('Expected number, got: %r' % e)
+
+
+def represent(expr, **options):
+    """Represent the quantum expression in the given basis.
+
+    In quantum mechanics abstract states and operators can be represented in
+    various basis sets. Under this operation the follow transforms happen:
+
+    * Ket -> column vector or function
+    * Bra -> row vector of function
+    * Operator -> matrix or differential operator
+
+    This function is the top-level interface for this action.
+
+    This function walks the SymPy expression tree looking for ``QExpr``
+    instances that have a ``_represent`` method. This method is then called
+    and the object is replaced by the representation returned by this method.
+    By default, the ``_represent`` method will dispatch to other methods
+    that handle the representation logic for a particular basis set. The
+    naming convention for these methods is the following::
+
+        def _represent_FooBasis(self, e, basis, **options)
+
+    This function will have the logic for representing instances of its class
+    in the basis set having a class named ``FooBasis``.
+
+    Parameters
+    ==========
+
+    expr  : Expr
+        The expression to represent.
+    basis : Operator, basis set
+        An object that contains the information about the basis set. If an
+        operator is used, the basis is assumed to be the orthonormal
+        eigenvectors of that operator. In general though, the basis argument
+        can be any object that contains the basis set information.
+    options : dict
+        Key/value pairs of options that are passed to the underlying method
+        that finds the representation. These options can be used to
+        control how the representation is done. For example, this is where
+        the size of the basis set would be set.
+
+    Returns
+    =======
+
+    e : Expr
+        The SymPy expression of the represented quantum expression.
+
+    Examples
+    ========
+
+    Here we subclass ``Operator`` and ``Ket`` to create the z-spin operator
+    and its spin 1/2 up eigenstate. By defining the ``_represent_SzOp``
+    method, the ket can be represented in the z-spin basis.
+
+    >>> from sympy.physics.quantum import Operator, represent, Ket
+    >>> from sympy import Matrix
+
+    >>> class SzUpKet(Ket):
+    ...     def _represent_SzOp(self, basis, **options):
+    ...         return Matrix([1,0])
+    ...
+    >>> class SzOp(Operator):
+    ...     pass
+    ...
+    >>> sz = SzOp('Sz')
+    >>> up = SzUpKet('up')
+    >>> represent(up, basis=sz)
+    Matrix([
+    [1],
+    [0]])
+
+    Here we see an example of representations in a continuous
+    basis. We see that the result of representing various combinations
+    of cartesian position operators and kets give us continuous
+    expressions involving DiracDelta functions.
+
+    >>> from sympy.physics.quantum.cartesian import XOp, XKet, XBra
+    >>> X = XOp()
+    >>> x = XKet()
+    >>> y = XBra('y')
+    >>> represent(X*x)
+    x*DiracDelta(x - x_2)
+    >>> represent(X*x*y)
+    x*DiracDelta(x - x_3)*DiracDelta(x_1 - y)
+
+    """
+
+    format = options.get('format', 'sympy')
+    if format == 'numpy':
+        import numpy as np
+    if isinstance(expr, QExpr) and not isinstance(expr, OuterProduct):
+        options['replace_none'] = False
+        temp_basis = get_basis(expr, **options)
+        if temp_basis is not None:
+            options['basis'] = temp_basis
+        try:
+            return expr._represent(**options)
+        except NotImplementedError as strerr:
+            #If no _represent_FOO method exists, map to the
+            #appropriate basis state and try
+            #the other methods of representation
+            options['replace_none'] = True
+
+            if isinstance(expr, (KetBase, BraBase)):
+                try:
+                    return rep_innerproduct(expr, **options)
+                except NotImplementedError:
+                    raise NotImplementedError(strerr)
+            elif isinstance(expr, Operator):
+                try:
+                    return rep_expectation(expr, **options)
+                except NotImplementedError:
+                    raise NotImplementedError(strerr)
+            else:
+                raise NotImplementedError(strerr)
+    elif isinstance(expr, Add):
+        result = represent(expr.args[0], **options)
+        for args in expr.args[1:]:
+            # scipy.sparse doesn't support += so we use plain = here.
+            result = result + represent(args, **options)
+        return result
+    elif isinstance(expr, Pow):
+        base, exp = expr.as_base_exp()
+        if format in ('numpy', 'scipy.sparse'):
+            exp = _sympy_to_scalar(exp)
+        base = represent(base, **options)
+        # scipy.sparse doesn't support negative exponents
+        # and warns when inverting a matrix in csr format.
+        if format == 'scipy.sparse' and exp < 0:
+            from scipy.sparse.linalg import inv
+            exp = - exp
+            base = inv(base.tocsc()).tocsr()
+        if format == 'numpy':
+            return np.linalg.matrix_power(base, exp)
+        return base ** exp
+    elif isinstance(expr, TensorProduct):
+        new_args = [represent(arg, **options) for arg in expr.args]
+        return TensorProduct(*new_args)
+    elif isinstance(expr, Dagger):
+        return Dagger(represent(expr.args[0], **options))
+    elif isinstance(expr, Commutator):
+        A = expr.args[0]
+        B = expr.args[1]
+        return represent(Mul(A, B) - Mul(B, A), **options)
+    elif isinstance(expr, AntiCommutator):
+        A = expr.args[0]
+        B = expr.args[1]
+        return represent(Mul(A, B) + Mul(B, A), **options)
+    elif isinstance(expr, InnerProduct):
+        return represent(Mul(expr.bra, expr.ket), **options)
+    elif not isinstance(expr, (Mul, OuterProduct)):
+        # For numpy and scipy.sparse, we can only handle numerical prefactors.
+        if format in ('numpy', 'scipy.sparse'):
+            return _sympy_to_scalar(expr)
+        return expr
+
+    if not isinstance(expr, (Mul, OuterProduct)):
+        raise TypeError('Mul expected, got: %r' % expr)
+
+    if "index" in options:
+        options["index"] += 1
+    else:
+        options["index"] = 1
+
+    if "unities" not in options:
+        options["unities"] = []
+
+    result = represent(expr.args[-1], **options)
+    last_arg = expr.args[-1]
+
+    for arg in reversed(expr.args[:-1]):
+        if isinstance(last_arg, Operator):
+            options["index"] += 1
+            options["unities"].append(options["index"])
+        elif isinstance(last_arg, BraBase) and isinstance(arg, KetBase):
+            options["index"] += 1
+        elif isinstance(last_arg, KetBase) and isinstance(arg, Operator):
+            options["unities"].append(options["index"])
+        elif isinstance(last_arg, KetBase) and isinstance(arg, BraBase):
+            options["unities"].append(options["index"])
+
+        next_arg = represent(arg, **options)
+        if format == 'numpy' and isinstance(next_arg, np.ndarray):
+            # Must use np.matmult to "matrix multiply" two np.ndarray
+            result = np.matmul(next_arg, result)
+        else:
+            result = next_arg*result
+        last_arg = arg
+
+    # All three matrix formats create 1 by 1 matrices when inner products of
+    # vectors are taken. In these cases, we simply return a scalar.
+    result = flatten_scalar(result)
+
+    result = integrate_result(expr, result, **options)
+
+    return result
+
+
+def rep_innerproduct(expr, **options):
+    """
+    Returns an innerproduct like representation (e.g. ``<x'|x>``) for the
+    given state.
+
+    Attempts to calculate inner product with a bra from the specified
+    basis. Should only be passed an instance of KetBase or BraBase
+
+    Parameters
+    ==========
+
+    expr : KetBase or BraBase
+        The expression to be represented
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.represent import rep_innerproduct
+    >>> from sympy.physics.quantum.cartesian import XOp, XKet, PxOp, PxKet
+    >>> rep_innerproduct(XKet())
+    DiracDelta(x - x_1)
+    >>> rep_innerproduct(XKet(), basis=PxOp())
+    sqrt(2)*exp(-I*px_1*x/hbar)/(2*sqrt(hbar)*sqrt(pi))
+    >>> rep_innerproduct(PxKet(), basis=XOp())
+    sqrt(2)*exp(I*px*x_1/hbar)/(2*sqrt(hbar)*sqrt(pi))
+
+    """
+
+    if not isinstance(expr, (KetBase, BraBase)):
+        raise TypeError("expr passed is not a Bra or Ket")
+
+    basis = get_basis(expr, **options)
+
+    if not isinstance(basis, StateBase):
+        raise NotImplementedError("Can't form this representation!")
+
+    if "index" not in options:
+        options["index"] = 1
+
+    basis_kets = enumerate_states(basis, options["index"], 2)
+
+    if isinstance(expr, BraBase):
+        bra = expr
+        ket = (basis_kets[1] if basis_kets[0].dual == expr else basis_kets[0])
+    else:
+        bra = (basis_kets[1].dual if basis_kets[0]
+               == expr else basis_kets[0].dual)
+        ket = expr
+
+    prod = InnerProduct(bra, ket)
+    result = prod.doit()
+
+    format = options.get('format', 'sympy')
+    return expr._format_represent(result, format)
+
+
+def rep_expectation(expr, **options):
+    """
+    Returns an ``<x'|A|x>`` type representation for the given operator.
+
+    Parameters
+    ==========
+
+    expr : Operator
+        Operator to be represented in the specified basis
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.cartesian import XOp, PxOp, PxKet
+    >>> from sympy.physics.quantum.represent import rep_expectation
+    >>> rep_expectation(XOp())
+    x_1*DiracDelta(x_1 - x_2)
+    >>> rep_expectation(XOp(), basis=PxOp())
+    <px_2|*X*|px_1>
+    >>> rep_expectation(XOp(), basis=PxKet())
+    <px_2|*X*|px_1>
+
+    """
+
+    if "index" not in options:
+        options["index"] = 1
+
+    if not isinstance(expr, Operator):
+        raise TypeError("The passed expression is not an operator")
+
+    basis_state = get_basis(expr, **options)
+
+    if basis_state is None or not isinstance(basis_state, StateBase):
+        raise NotImplementedError("Could not get basis kets for this operator")
+
+    basis_kets = enumerate_states(basis_state, options["index"], 2)
+
+    bra = basis_kets[1].dual
+    ket = basis_kets[0]
+
+    return qapply(bra*expr*ket)
+
+
+def integrate_result(orig_expr, result, **options):
+    """
+    Returns the result of integrating over any unities ``(|x><x|)`` in
+    the given expression. Intended for integrating over the result of
+    representations in continuous bases.
+
+    This function integrates over any unities that may have been
+    inserted into the quantum expression and returns the result.
+    It uses the interval of the Hilbert space of the basis state
+    passed to it in order to figure out the limits of integration.
+    The unities option must be
+    specified for this to work.
+
+    Note: This is mostly used internally by represent(). Examples are
+    given merely to show the use cases.
+
+    Parameters
+    ==========
+
+    orig_expr : quantum expression
+        The original expression which was to be represented
+
+    result: Expr
+        The resulting representation that we wish to integrate over
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, DiracDelta
+    >>> from sympy.physics.quantum.represent import integrate_result
+    >>> from sympy.physics.quantum.cartesian import XOp, XKet
+    >>> x_ket = XKet()
+    >>> X_op = XOp()
+    >>> x, x_1, x_2 = symbols('x, x_1, x_2')
+    >>> integrate_result(X_op*x_ket, x*DiracDelta(x-x_1)*DiracDelta(x_1-x_2))
+    x*DiracDelta(x - x_1)*DiracDelta(x_1 - x_2)
+    >>> integrate_result(X_op*x_ket, x*DiracDelta(x-x_1)*DiracDelta(x_1-x_2),
+    ...     unities=[1])
+    x*DiracDelta(x - x_2)
+
+    """
+    if not isinstance(result, Expr):
+        return result
+
+    options['replace_none'] = True
+    if "basis" not in options:
+        arg = orig_expr.args[-1]
+        options["basis"] = get_basis(arg, **options)
+    elif not isinstance(options["basis"], StateBase):
+        options["basis"] = get_basis(orig_expr, **options)
+
+    basis = options.pop("basis", None)
+
+    if basis is None:
+        return result
+
+    unities = options.pop("unities", [])
+
+    if len(unities) == 0:
+        return result
+
+    kets = enumerate_states(basis, unities)
+    coords = [k.label[0] for k in kets]
+
+    for coord in coords:
+        if coord in result.free_symbols:
+            #TODO: Add support for sets of operators
+            basis_op = state_to_operators(basis)
+            start = basis_op.hilbert_space.interval.start
+            end = basis_op.hilbert_space.interval.end
+            result = integrate(result, (coord, start, end))
+
+    return result
+
+
+def get_basis(expr, *, basis=None, replace_none=True, **options):
+    """
+    Returns a basis state instance corresponding to the basis specified in
+    options=s. If no basis is specified, the function tries to form a default
+    basis state of the given expression.
+
+    There are three behaviors:
+
+    1. The basis specified in options is already an instance of StateBase. If
+       this is the case, it is simply returned. If the class is specified but
+       not an instance, a default instance is returned.
+
+    2. The basis specified is an operator or set of operators. If this
+       is the case, the operator_to_state mapping method is used.
+
+    3. No basis is specified. If expr is a state, then a default instance of
+       its class is returned.  If expr is an operator, then it is mapped to the
+       corresponding state.  If it is neither, then we cannot obtain the basis
+       state.
+
+    If the basis cannot be mapped, then it is not changed.
+
+    This will be called from within represent, and represent will
+    only pass QExpr's.
+
+    TODO (?): Support for Muls and other types of expressions?
+
+    Parameters
+    ==========
+
+    expr : Operator or StateBase
+        Expression whose basis is sought
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.represent import get_basis
+    >>> from sympy.physics.quantum.cartesian import XOp, XKet, PxOp, PxKet
+    >>> x = XKet()
+    >>> X = XOp()
+    >>> get_basis(x)
+    |x>
+    >>> get_basis(X)
+    |x>
+    >>> get_basis(x, basis=PxOp())
+    |px>
+    >>> get_basis(x, basis=PxKet)
+    |px>
+
+    """
+
+    if basis is None and not replace_none:
+        return None
+
+    if basis is None:
+        if isinstance(expr, KetBase):
+            return _make_default(expr.__class__)
+        elif isinstance(expr, BraBase):
+            return _make_default(expr.dual_class())
+        elif isinstance(expr, Operator):
+            state_inst = operators_to_state(expr)
+            return (state_inst if state_inst is not None else None)
+        else:
+            return None
+    elif (isinstance(basis, Operator) or
+          (not isinstance(basis, StateBase) and issubclass(basis, Operator))):
+        state = operators_to_state(basis)
+        if state is None:
+            return None
+        elif isinstance(state, StateBase):
+            return state
+        else:
+            return _make_default(state)
+    elif isinstance(basis, StateBase):
+        return basis
+    elif issubclass(basis, StateBase):
+        return _make_default(basis)
+    else:
+        return None
+
+
+def _make_default(expr):
+    # XXX: Catching TypeError like this is a bad way of distinguishing
+    # instances from classes. The logic using this function should be
+    # rewritten somehow.
+    try:
+        expr = expr()
+    except TypeError:
+        return expr
+
+    return expr
+
+
+def enumerate_states(*args, **options):
+    """
+    Returns instances of the given state with dummy indices appended
+
+    Operates in two different modes:
+
+    1. Two arguments are passed to it. The first is the base state which is to
+       be indexed, and the second argument is a list of indices to append.
+
+    2. Three arguments are passed. The first is again the base state to be
+       indexed. The second is the start index for counting.  The final argument
+       is the number of kets you wish to receive.
+
+    Tries to call state._enumerate_state. If this fails, returns an empty list
+
+    Parameters
+    ==========
+
+    args : list
+        See list of operation modes above for explanation
+
+    Examples
+    ========
+
+    >>> from sympy.physics.quantum.cartesian import XBra, XKet
+    >>> from sympy.physics.quantum.represent import enumerate_states
+    >>> test = XKet('foo')
+    >>> enumerate_states(test, 1, 3)
+    [|foo_1>, |foo_2>, |foo_3>]
+    >>> test2 = XBra('bar')
+    >>> enumerate_states(test2, [4, 5, 10])
+    [<bar_4|, <bar_5|, <bar_10|]
+
+    """
+
+    state = args[0]
+
+    if len(args) not in (2, 3):
+        raise NotImplementedError("Wrong number of arguments!")
+
+    if not isinstance(state, StateBase):
+        raise TypeError("First argument is not a state!")
+
+    if len(args) == 3:
+        num_states = args[2]
+        options['start_index'] = args[1]
+    else:
+        num_states = len(args[1])
+        options['index_list'] = args[1]
+
+    try:
+        ret = state._enumerate_state(num_states, **options)
+    except NotImplementedError:
+        ret = []
+
+    return ret

venv/lib/python3.10/site-packages/sympy/physics/quantum/sho1d.py

@@ -0,0 +1,679 @@
+"""Simple Harmonic Oscillator 1-Dimension"""
+
+from sympy.core.numbers import (I, Integer)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.quantum.constants import hbar
+from sympy.physics.quantum.operator import Operator
+from sympy.physics.quantum.state import Bra, Ket, State
+from sympy.physics.quantum.qexpr import QExpr
+from sympy.physics.quantum.cartesian import X, Px
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.physics.quantum.hilbert import ComplexSpace
+from sympy.physics.quantum.matrixutils import matrix_zeros
+
+#------------------------------------------------------------------------------
+
+class SHOOp(Operator):
+    """A base class for the SHO Operators.
+
+    We are limiting the number of arguments to be 1.
+
+    """
+
+    @classmethod
+    def _eval_args(cls, args):
+        args = QExpr._eval_args(args)
+        if len(args) == 1:
+            return args
+        else:
+            raise ValueError("Too many arguments")
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return ComplexSpace(S.Infinity)
+
+class RaisingOp(SHOOp):
+    """The Raising Operator or a^dagger.
+
+    When a^dagger acts on a state it raises the state up by one. Taking
+    the adjoint of a^dagger returns 'a', the Lowering Operator. a^dagger
+    can be rewritten in terms of position and momentum. We can represent
+    a^dagger as a matrix, which will be its default basis.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        operator.
+
+    Examples
+    ========
+
+    Create a Raising Operator and rewrite it in terms of position and
+    momentum, and show that taking its adjoint returns 'a':
+
+        >>> from sympy.physics.quantum.sho1d import RaisingOp
+        >>> from sympy.physics.quantum import Dagger
+
+        >>> ad = RaisingOp('a')
+        >>> ad.rewrite('xp').doit()
+        sqrt(2)*(m*omega*X - I*Px)/(2*sqrt(hbar)*sqrt(m*omega))
+
+        >>> Dagger(ad)
+        a
+
+    Taking the commutator of a^dagger with other Operators:
+
+        >>> from sympy.physics.quantum import Commutator
+        >>> from sympy.physics.quantum.sho1d import RaisingOp, LoweringOp
+        >>> from sympy.physics.quantum.sho1d import NumberOp
+
+        >>> ad = RaisingOp('a')
+        >>> a = LoweringOp('a')
+        >>> N = NumberOp('N')
+        >>> Commutator(ad, a).doit()
+        -1
+        >>> Commutator(ad, N).doit()
+        -RaisingOp(a)
+
+    Apply a^dagger to a state:
+
+        >>> from sympy.physics.quantum import qapply
+        >>> from sympy.physics.quantum.sho1d import RaisingOp, SHOKet
+
+        >>> ad = RaisingOp('a')
+        >>> k = SHOKet('k')
+        >>> qapply(ad*k)
+        sqrt(k + 1)*|k + 1>
+
+    Matrix Representation
+
+        >>> from sympy.physics.quantum.sho1d import RaisingOp
+        >>> from sympy.physics.quantum.represent import represent
+        >>> ad = RaisingOp('a')
+        >>> represent(ad, basis=N, ndim=4, format='sympy')
+        Matrix([
+        [0,       0,       0, 0],
+        [1,       0,       0, 0],
+        [0, sqrt(2),       0, 0],
+        [0,       0, sqrt(3), 0]])
+
+    """
+
+    def _eval_rewrite_as_xp(self, *args, **kwargs):
+        return (S.One/sqrt(Integer(2)*hbar*m*omega))*(
+            S.NegativeOne*I*Px + m*omega*X)
+
+    def _eval_adjoint(self):
+        return LoweringOp(*self.args)
+
+    def _eval_commutator_LoweringOp(self, other):
+        return S.NegativeOne
+
+    def _eval_commutator_NumberOp(self, other):
+        return S.NegativeOne*self
+
+    def _apply_operator_SHOKet(self, ket, **options):
+        temp = ket.n + S.One
+        return sqrt(temp)*SHOKet(temp)
+
+    def _represent_default_basis(self, **options):
+        return self._represent_NumberOp(None, **options)
+
+    def _represent_XOp(self, basis, **options):
+        # This logic is good but the underlying position
+        # representation logic is broken.
+        # temp = self.rewrite('xp').doit()
+        # result = represent(temp, basis=X)
+        # return result
+        raise NotImplementedError('Position representation is not implemented')
+
+    def _represent_NumberOp(self, basis, **options):
+        ndim_info = options.get('ndim', 4)
+        format = options.get('format','sympy')
+        matrix = matrix_zeros(ndim_info, ndim_info, **options)
+        for i in range(ndim_info - 1):
+            value = sqrt(i + 1)
+            if format == 'scipy.sparse':
+                value = float(value)
+            matrix[i + 1, i] = value
+        if format == 'scipy.sparse':
+            matrix = matrix.tocsr()
+        return matrix
+
+    #--------------------------------------------------------------------------
+    # Printing Methods
+    #--------------------------------------------------------------------------
+
+    def _print_contents(self, printer, *args):
+        arg0 = printer._print(self.args[0], *args)
+        return '%s(%s)' % (self.__class__.__name__, arg0)
+
+    def _print_contents_pretty(self, printer, *args):
+        from sympy.printing.pretty.stringpict import prettyForm
+        pform = printer._print(self.args[0], *args)
+        pform = pform**prettyForm('\N{DAGGER}')
+        return pform
+
+    def _print_contents_latex(self, printer, *args):
+        arg = printer._print(self.args[0])
+        return '%s^{\\dagger}' % arg
+
+class LoweringOp(SHOOp):
+    """The Lowering Operator or 'a'.
+
+    When 'a' acts on a state it lowers the state up by one. Taking
+    the adjoint of 'a' returns a^dagger, the Raising Operator. 'a'
+    can be rewritten in terms of position and momentum. We can
+    represent 'a' as a matrix, which will be its default basis.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        operator.
+
+    Examples
+    ========
+
+    Create a Lowering Operator and rewrite it in terms of position and
+    momentum, and show that taking its adjoint returns a^dagger:
+
+        >>> from sympy.physics.quantum.sho1d import LoweringOp
+        >>> from sympy.physics.quantum import Dagger
+
+        >>> a = LoweringOp('a')
+        >>> a.rewrite('xp').doit()
+        sqrt(2)*(m*omega*X + I*Px)/(2*sqrt(hbar)*sqrt(m*omega))
+
+        >>> Dagger(a)
+        RaisingOp(a)
+
+    Taking the commutator of 'a' with other Operators:
+
+        >>> from sympy.physics.quantum import Commutator
+        >>> from sympy.physics.quantum.sho1d import LoweringOp, RaisingOp
+        >>> from sympy.physics.quantum.sho1d import NumberOp
+
+        >>> a = LoweringOp('a')
+        >>> ad = RaisingOp('a')
+        >>> N = NumberOp('N')
+        >>> Commutator(a, ad).doit()
+        1
+        >>> Commutator(a, N).doit()
+        a
+
+    Apply 'a' to a state:
+
+        >>> from sympy.physics.quantum import qapply
+        >>> from sympy.physics.quantum.sho1d import LoweringOp, SHOKet
+
+        >>> a = LoweringOp('a')
+        >>> k = SHOKet('k')
+        >>> qapply(a*k)
+        sqrt(k)*|k - 1>
+
+    Taking 'a' of the lowest state will return 0:
+
+        >>> from sympy.physics.quantum import qapply
+        >>> from sympy.physics.quantum.sho1d import LoweringOp, SHOKet
+
+        >>> a = LoweringOp('a')
+        >>> k = SHOKet(0)
+        >>> qapply(a*k)
+        0
+
+    Matrix Representation
+
+        >>> from sympy.physics.quantum.sho1d import LoweringOp
+        >>> from sympy.physics.quantum.represent import represent
+        >>> a = LoweringOp('a')
+        >>> represent(a, basis=N, ndim=4, format='sympy')
+        Matrix([
+        [0, 1,       0,       0],
+        [0, 0, sqrt(2),       0],
+        [0, 0,       0, sqrt(3)],
+        [0, 0,       0,       0]])
+
+    """
+
+    def _eval_rewrite_as_xp(self, *args, **kwargs):
+        return (S.One/sqrt(Integer(2)*hbar*m*omega))*(
+            I*Px + m*omega*X)
+
+    def _eval_adjoint(self):
+        return RaisingOp(*self.args)
+
+    def _eval_commutator_RaisingOp(self, other):
+        return S.One
+
+    def _eval_commutator_NumberOp(self, other):
+        return self
+
+    def _apply_operator_SHOKet(self, ket, **options):
+        temp = ket.n - Integer(1)
+        if ket.n is S.Zero:
+            return S.Zero
+        else:
+            return sqrt(ket.n)*SHOKet(temp)
+
+    def _represent_default_basis(self, **options):
+        return self._represent_NumberOp(None, **options)
+
+    def _represent_XOp(self, basis, **options):
+        # This logic is good but the underlying position
+        # representation logic is broken.
+        # temp = self.rewrite('xp').doit()
+        # result = represent(temp, basis=X)
+        # return result
+        raise NotImplementedError('Position representation is not implemented')
+
+    def _represent_NumberOp(self, basis, **options):
+        ndim_info = options.get('ndim', 4)
+        format = options.get('format', 'sympy')
+        matrix = matrix_zeros(ndim_info, ndim_info, **options)
+        for i in range(ndim_info - 1):
+            value = sqrt(i + 1)
+            if format == 'scipy.sparse':
+                value = float(value)
+            matrix[i,i + 1] = value
+        if format == 'scipy.sparse':
+            matrix = matrix.tocsr()
+        return matrix
+
+
+class NumberOp(SHOOp):
+    """The Number Operator is simply a^dagger*a
+
+    It is often useful to write a^dagger*a as simply the Number Operator
+    because the Number Operator commutes with the Hamiltonian. And can be
+    expressed using the Number Operator. Also the Number Operator can be
+    applied to states. We can represent the Number Operator as a matrix,
+    which will be its default basis.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        operator.
+
+    Examples
+    ========
+
+    Create a Number Operator and rewrite it in terms of the ladder
+    operators, position and momentum operators, and Hamiltonian:
+
+        >>> from sympy.physics.quantum.sho1d import NumberOp
+
+        >>> N = NumberOp('N')
+        >>> N.rewrite('a').doit()
+        RaisingOp(a)*a
+        >>> N.rewrite('xp').doit()
+        -1/2 + (m**2*omega**2*X**2 + Px**2)/(2*hbar*m*omega)
+        >>> N.rewrite('H').doit()
+        -1/2 + H/(hbar*omega)
+
+    Take the Commutator of the Number Operator with other Operators:
+
+        >>> from sympy.physics.quantum import Commutator
+        >>> from sympy.physics.quantum.sho1d import NumberOp, Hamiltonian
+        >>> from sympy.physics.quantum.sho1d import RaisingOp, LoweringOp
+
+        >>> N = NumberOp('N')
+        >>> H = Hamiltonian('H')
+        >>> ad = RaisingOp('a')
+        >>> a = LoweringOp('a')
+        >>> Commutator(N,H).doit()
+        0
+        >>> Commutator(N,ad).doit()
+        RaisingOp(a)
+        >>> Commutator(N,a).doit()
+        -a
+
+    Apply the Number Operator to a state:
+
+        >>> from sympy.physics.quantum import qapply
+        >>> from sympy.physics.quantum.sho1d import NumberOp, SHOKet
+
+        >>> N = NumberOp('N')
+        >>> k = SHOKet('k')
+        >>> qapply(N*k)
+        k*|k>
+
+    Matrix Representation
+
+        >>> from sympy.physics.quantum.sho1d import NumberOp
+        >>> from sympy.physics.quantum.represent import represent
+        >>> N = NumberOp('N')
+        >>> represent(N, basis=N, ndim=4, format='sympy')
+        Matrix([
+        [0, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 2, 0],
+        [0, 0, 0, 3]])
+
+    """
+
+    def _eval_rewrite_as_a(self, *args, **kwargs):
+        return ad*a
+
+    def _eval_rewrite_as_xp(self, *args, **kwargs):
+        return (S.One/(Integer(2)*m*hbar*omega))*(Px**2 + (
+            m*omega*X)**2) - S.Half
+
+    def _eval_rewrite_as_H(self, *args, **kwargs):
+        return H/(hbar*omega) - S.Half
+
+    def _apply_operator_SHOKet(self, ket, **options):
+        return ket.n*ket
+
+    def _eval_commutator_Hamiltonian(self, other):
+        return S.Zero
+
+    def _eval_commutator_RaisingOp(self, other):
+        return other
+
+    def _eval_commutator_LoweringOp(self, other):
+        return S.NegativeOne*other
+
+    def _represent_default_basis(self, **options):
+        return self._represent_NumberOp(None, **options)
+
+    def _represent_XOp(self, basis, **options):
+        # This logic is good but the underlying position
+        # representation logic is broken.
+        # temp = self.rewrite('xp').doit()
+        # result = represent(temp, basis=X)
+        # return result
+        raise NotImplementedError('Position representation is not implemented')
+
+    def _represent_NumberOp(self, basis, **options):
+        ndim_info = options.get('ndim', 4)
+        format = options.get('format', 'sympy')
+        matrix = matrix_zeros(ndim_info, ndim_info, **options)
+        for i in range(ndim_info):
+            value = i
+            if format == 'scipy.sparse':
+                value = float(value)
+            matrix[i,i] = value
+        if format == 'scipy.sparse':
+            matrix = matrix.tocsr()
+        return matrix
+
+
+class Hamiltonian(SHOOp):
+    """The Hamiltonian Operator.
+
+    The Hamiltonian is used to solve the time-independent Schrodinger
+    equation. The Hamiltonian can be expressed using the ladder operators,
+    as well as by position and momentum. We can represent the Hamiltonian
+    Operator as a matrix, which will be its default basis.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        operator.
+
+    Examples
+    ========
+
+    Create a Hamiltonian Operator and rewrite it in terms of the ladder
+    operators, position and momentum, and the Number Operator:
+
+        >>> from sympy.physics.quantum.sho1d import Hamiltonian
+
+        >>> H = Hamiltonian('H')
+        >>> H.rewrite('a').doit()
+        hbar*omega*(1/2 + RaisingOp(a)*a)
+        >>> H.rewrite('xp').doit()
+        (m**2*omega**2*X**2 + Px**2)/(2*m)
+        >>> H.rewrite('N').doit()
+        hbar*omega*(1/2 + N)
+
+    Take the Commutator of the Hamiltonian and the Number Operator:
+
+        >>> from sympy.physics.quantum import Commutator
+        >>> from sympy.physics.quantum.sho1d import Hamiltonian, NumberOp
+
+        >>> H = Hamiltonian('H')
+        >>> N = NumberOp('N')
+        >>> Commutator(H,N).doit()
+        0
+
+    Apply the Hamiltonian Operator to a state:
+
+        >>> from sympy.physics.quantum import qapply
+        >>> from sympy.physics.quantum.sho1d import Hamiltonian, SHOKet
+
+        >>> H = Hamiltonian('H')
+        >>> k = SHOKet('k')
+        >>> qapply(H*k)
+        hbar*k*omega*|k> + hbar*omega*|k>/2
+
+    Matrix Representation
+
+        >>> from sympy.physics.quantum.sho1d import Hamiltonian
+        >>> from sympy.physics.quantum.represent import represent
+
+        >>> H = Hamiltonian('H')
+        >>> represent(H, basis=N, ndim=4, format='sympy')
+        Matrix([
+        [hbar*omega/2,              0,              0,              0],
+        [           0, 3*hbar*omega/2,              0,              0],
+        [           0,              0, 5*hbar*omega/2,              0],
+        [           0,              0,              0, 7*hbar*omega/2]])
+
+    """
+
+    def _eval_rewrite_as_a(self, *args, **kwargs):
+        return hbar*omega*(ad*a + S.Half)
+
+    def _eval_rewrite_as_xp(self, *args, **kwargs):
+        return (S.One/(Integer(2)*m))*(Px**2 + (m*omega*X)**2)
+
+    def _eval_rewrite_as_N(self, *args, **kwargs):
+        return hbar*omega*(N + S.Half)
+
+    def _apply_operator_SHOKet(self, ket, **options):
+        return (hbar*omega*(ket.n + S.Half))*ket
+
+    def _eval_commutator_NumberOp(self, other):
+        return S.Zero
+
+    def _represent_default_basis(self, **options):
+        return self._represent_NumberOp(None, **options)
+
+    def _represent_XOp(self, basis, **options):
+        # This logic is good but the underlying position
+        # representation logic is broken.
+        # temp = self.rewrite('xp').doit()
+        # result = represent(temp, basis=X)
+        # return result
+        raise NotImplementedError('Position representation is not implemented')
+
+    def _represent_NumberOp(self, basis, **options):
+        ndim_info = options.get('ndim', 4)
+        format = options.get('format', 'sympy')
+        matrix = matrix_zeros(ndim_info, ndim_info, **options)
+        for i in range(ndim_info):
+            value = i + S.Half
+            if format == 'scipy.sparse':
+                value = float(value)
+            matrix[i,i] = value
+        if format == 'scipy.sparse':
+            matrix = matrix.tocsr()
+        return hbar*omega*matrix
+
+#------------------------------------------------------------------------------
+
+class SHOState(State):
+    """State class for SHO states"""
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return ComplexSpace(S.Infinity)
+
+    @property
+    def n(self):
+        return self.args[0]
+
+
+class SHOKet(SHOState, Ket):
+    """1D eigenket.
+
+    Inherits from SHOState and Ket.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the ket
+        This is usually its quantum numbers or its symbol.
+
+    Examples
+    ========
+
+    Ket's know about their associated bra:
+
+        >>> from sympy.physics.quantum.sho1d import SHOKet
+
+        >>> k = SHOKet('k')
+        >>> k.dual
+        <k|
+        >>> k.dual_class()
+        <class 'sympy.physics.quantum.sho1d.SHOBra'>
+
+    Take the Inner Product with a bra:
+
+        >>> from sympy.physics.quantum import InnerProduct
+        >>> from sympy.physics.quantum.sho1d import SHOKet, SHOBra
+
+        >>> k = SHOKet('k')
+        >>> b = SHOBra('b')
+        >>> InnerProduct(b,k).doit()
+        KroneckerDelta(b, k)
+
+    Vector representation of a numerical state ket:
+
+        >>> from sympy.physics.quantum.sho1d import SHOKet, NumberOp
+        >>> from sympy.physics.quantum.represent import represent
+
+        >>> k = SHOKet(3)
+        >>> N = NumberOp('N')
+        >>> represent(k, basis=N, ndim=4)
+        Matrix([
+        [0],
+        [0],
+        [0],
+        [1]])
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return SHOBra
+
+    def _eval_innerproduct_SHOBra(self, bra, **hints):
+        result = KroneckerDelta(self.n, bra.n)
+        return result
+
+    def _represent_default_basis(self, **options):
+        return self._represent_NumberOp(None, **options)
+
+    def _represent_NumberOp(self, basis, **options):
+        ndim_info = options.get('ndim', 4)
+        format = options.get('format', 'sympy')
+        options['spmatrix'] = 'lil'
+        vector = matrix_zeros(ndim_info, 1, **options)
+        if isinstance(self.n, Integer):
+            if self.n >= ndim_info:
+                return ValueError("N-Dimension too small")
+            if format == 'scipy.sparse':
+                vector[int(self.n), 0] = 1.0
+                vector = vector.tocsr()
+            elif format == 'numpy':
+                vector[int(self.n), 0] = 1.0
+            else:
+                vector[self.n, 0] = S.One
+            return vector
+        else:
+            return ValueError("Not Numerical State")
+
+
+class SHOBra(SHOState, Bra):
+    """A time-independent Bra in SHO.
+
+    Inherits from SHOState and Bra.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the ket
+        This is usually its quantum numbers or its symbol.
+
+    Examples
+    ========
+
+    Bra's know about their associated ket:
+
+        >>> from sympy.physics.quantum.sho1d import SHOBra
+
+        >>> b = SHOBra('b')
+        >>> b.dual
+        |b>
+        >>> b.dual_class()
+        <class 'sympy.physics.quantum.sho1d.SHOKet'>
+
+    Vector representation of a numerical state bra:
+
+        >>> from sympy.physics.quantum.sho1d import SHOBra, NumberOp
+        >>> from sympy.physics.quantum.represent import represent
+
+        >>> b = SHOBra(3)
+        >>> N = NumberOp('N')
+        >>> represent(b, basis=N, ndim=4)
+        Matrix([[0, 0, 0, 1]])
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return SHOKet
+
+    def _represent_default_basis(self, **options):
+        return self._represent_NumberOp(None, **options)
+
+    def _represent_NumberOp(self, basis, **options):
+        ndim_info = options.get('ndim', 4)
+        format = options.get('format', 'sympy')
+        options['spmatrix'] = 'lil'
+        vector = matrix_zeros(1, ndim_info, **options)
+        if isinstance(self.n, Integer):
+            if self.n >= ndim_info:
+                return ValueError("N-Dimension too small")
+            if format == 'scipy.sparse':
+                vector[0, int(self.n)] = 1.0
+                vector = vector.tocsr()
+            elif format == 'numpy':
+                vector[0, int(self.n)] = 1.0
+            else:
+                vector[0, self.n] = S.One
+            return vector
+        else:
+            return ValueError("Not Numerical State")
+
+
+ad = RaisingOp('a')
+a = LoweringOp('a')
+H = Hamiltonian('H')
+N = NumberOp('N')
+omega = Symbol('omega')
+m = Symbol('m')

venv/lib/python3.10/site-packages/sympy/physics/quantum/shor.py

@@ -0,0 +1,173 @@
+"""Shor's algorithm and helper functions.
+
+Todo:
+
+* Get the CMod gate working again using the new Gate API.
+* Fix everything.
+* Update docstrings and reformat.
+"""
+
+import math
+import random
+
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core.numbers import igcd
+from sympy.ntheory import continued_fraction_periodic as continued_fraction
+from sympy.utilities.iterables import variations
+
+from sympy.physics.quantum.gate import Gate
+from sympy.physics.quantum.qubit import Qubit, measure_partial_oneshot
+from sympy.physics.quantum.qapply import qapply
+from sympy.physics.quantum.qft import QFT
+from sympy.physics.quantum.qexpr import QuantumError
+
+
+class OrderFindingException(QuantumError):
+    pass
+
+
+class CMod(Gate):
+    """A controlled mod gate.
+
+    This is black box controlled Mod function for use by shor's algorithm.
+    TODO: implement a decompose property that returns how to do this in terms
+    of elementary gates
+    """
+
+    @classmethod
+    def _eval_args(cls, args):
+        # t = args[0]
+        # a = args[1]
+        # N = args[2]
+        raise NotImplementedError('The CMod gate has not been completed.')
+
+    @property
+    def t(self):
+        """Size of 1/2 input register.  First 1/2 holds output."""
+        return self.label[0]
+
+    @property
+    def a(self):
+        """Base of the controlled mod function."""
+        return self.label[1]
+
+    @property
+    def N(self):
+        """N is the type of modular arithmetic we are doing."""
+        return self.label[2]
+
+    def _apply_operator_Qubit(self, qubits, **options):
+        """
+            This directly calculates the controlled mod of the second half of
+            the register and puts it in the second
+            This will look pretty when we get Tensor Symbolically working
+        """
+        n = 1
+        k = 0
+        # Determine the value stored in high memory.
+        for i in range(self.t):
+            k += n*qubits[self.t + i]
+            n *= 2
+
+        # The value to go in low memory will be out.
+        out = int(self.a**k % self.N)
+
+        # Create array for new qbit-ket which will have high memory unaffected
+        outarray = list(qubits.args[0][:self.t])
+
+        # Place out in low memory
+        for i in reversed(range(self.t)):
+            outarray.append((out >> i) & 1)
+
+        return Qubit(*outarray)
+
+
+def shor(N):
+    """This function implements Shor's factoring algorithm on the Integer N
+
+    The algorithm starts by picking a random number (a) and seeing if it is
+    coprime with N. If it is not, then the gcd of the two numbers is a factor
+    and we are done. Otherwise, it begins the period_finding subroutine which
+    finds the period of a in modulo N arithmetic. This period, if even, can
+    be used to calculate factors by taking a**(r/2)-1 and a**(r/2)+1.
+    These values are returned.
+    """
+    a = random.randrange(N - 2) + 2
+    if igcd(N, a) != 1:
+        return igcd(N, a)
+    r = period_find(a, N)
+    if r % 2 == 1:
+        shor(N)
+    answer = (igcd(a**(r/2) - 1, N), igcd(a**(r/2) + 1, N))
+    return answer
+
+
+def getr(x, y, N):
+    fraction = continued_fraction(x, y)
+    # Now convert into r
+    total = ratioize(fraction, N)
+    return total
+
+
+def ratioize(list, N):
+    if list[0] > N:
+        return S.Zero
+    if len(list) == 1:
+        return list[0]
+    return list[0] + ratioize(list[1:], N)
+
+
+def period_find(a, N):
+    """Finds the period of a in modulo N arithmetic
+
+    This is quantum part of Shor's algorithm. It takes two registers,
+    puts first in superposition of states with Hadamards so: ``|k>|0>``
+    with k being all possible choices. It then does a controlled mod and
+    a QFT to determine the order of a.
+    """
+    epsilon = .5
+    # picks out t's such that maintains accuracy within epsilon
+    t = int(2*math.ceil(log(N, 2)))
+    # make the first half of register be 0's |000...000>
+    start = [0 for x in range(t)]
+    # Put second half into superposition of states so we have |1>x|0> + |2>x|0> + ... |k>x>|0> + ... + |2**n-1>x|0>
+    factor = 1/sqrt(2**t)
+    qubits = 0
+    for arr in variations(range(2), t, repetition=True):
+        qbitArray = list(arr) + start
+        qubits = qubits + Qubit(*qbitArray)
+    circuit = (factor*qubits).expand()
+    # Controlled second half of register so that we have:
+    # |1>x|a**1 %N> + |2>x|a**2 %N> + ... + |k>x|a**k %N >+ ... + |2**n-1=k>x|a**k % n>
+    circuit = CMod(t, a, N)*circuit
+    # will measure first half of register giving one of the a**k%N's
+
+    circuit = qapply(circuit)
+    for i in range(t):
+        circuit = measure_partial_oneshot(circuit, i)
+    # Now apply Inverse Quantum Fourier Transform on the second half of the register
+
+    circuit = qapply(QFT(t, t*2).decompose()*circuit, floatingPoint=True)
+    for i in range(t):
+        circuit = measure_partial_oneshot(circuit, i + t)
+    if isinstance(circuit, Qubit):
+        register = circuit
+    elif isinstance(circuit, Mul):
+        register = circuit.args[-1]
+    else:
+        register = circuit.args[-1].args[-1]
+
+    n = 1
+    answer = 0
+    for i in range(len(register)/2):
+        answer += n*register[i + t]
+        n = n << 1
+    if answer == 0:
+        raise OrderFindingException(
+            "Order finder returned 0. Happens with chance %f" % epsilon)
+    #turn answer into r using continued fractions
+    g = getr(answer, 2**t, N)
+    return g

venv/lib/python3.10/site-packages/sympy/physics/quantum/spin.py

@@ -0,0 +1,2149 @@
+"""Quantum mechanical angular momemtum."""
+
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Integer, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.simplify.simplify import simplify
+from sympy.matrices import zeros
+from sympy.printing.pretty.stringpict import prettyForm, stringPict
+from sympy.printing.pretty.pretty_symbology import pretty_symbol
+
+from sympy.physics.quantum.qexpr import QExpr
+from sympy.physics.quantum.operator import (HermitianOperator, Operator,
+                                            UnitaryOperator)
+from sympy.physics.quantum.state import Bra, Ket, State
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.physics.quantum.constants import hbar
+from sympy.physics.quantum.hilbert import ComplexSpace, DirectSumHilbertSpace
+from sympy.physics.quantum.tensorproduct import TensorProduct
+from sympy.physics.quantum.cg import CG
+from sympy.physics.quantum.qapply import qapply
+
+
+__all__ = [
+    'm_values',
+    'Jplus',
+    'Jminus',
+    'Jx',
+    'Jy',
+    'Jz',
+    'J2',
+    'Rotation',
+    'WignerD',
+    'JxKet',
+    'JxBra',
+    'JyKet',
+    'JyBra',
+    'JzKet',
+    'JzBra',
+    'JzOp',
+    'J2Op',
+    'JxKetCoupled',
+    'JxBraCoupled',
+    'JyKetCoupled',
+    'JyBraCoupled',
+    'JzKetCoupled',
+    'JzBraCoupled',
+    'couple',
+    'uncouple'
+]
+
+
+def m_values(j):
+    j = sympify(j)
+    size = 2*j + 1
+    if not size.is_Integer or not size > 0:
+        raise ValueError(
+            'Only integer or half-integer values allowed for j, got: : %r' % j
+        )
+    return size, [j - i for i in range(int(2*j + 1))]
+
+
+#-----------------------------------------------------------------------------
+# Spin Operators
+#-----------------------------------------------------------------------------
+
+
+class SpinOpBase:
+    """Base class for spin operators."""
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        # We consider all j values so our space is infinite.
+        return ComplexSpace(S.Infinity)
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    def _print_contents(self, printer, *args):
+        return '%s%s' % (self.name, self._coord)
+
+    def _print_contents_pretty(self, printer, *args):
+        a = stringPict(str(self.name))
+        b = stringPict(self._coord)
+        return self._print_subscript_pretty(a, b)
+
+    def _print_contents_latex(self, printer, *args):
+        return r'%s_%s' % ((self.name, self._coord))
+
+    def _represent_base(self, basis, **options):
+        j = options.get('j', S.Half)
+        size, mvals = m_values(j)
+        result = zeros(size, size)
+        for p in range(size):
+            for q in range(size):
+                me = self.matrix_element(j, mvals[p], j, mvals[q])
+                result[p, q] = me
+        return result
+
+    def _apply_op(self, ket, orig_basis, **options):
+        state = ket.rewrite(self.basis)
+        # If the state has only one term
+        if isinstance(state, State):
+            ret = (hbar*state.m)*state
+        # state is a linear combination of states
+        elif isinstance(state, Sum):
+            ret = self._apply_operator_Sum(state, **options)
+        else:
+            ret = qapply(self*state)
+        if ret == self*state:
+            raise NotImplementedError
+        return ret.rewrite(orig_basis)
+
+    def _apply_operator_JxKet(self, ket, **options):
+        return self._apply_op(ket, 'Jx', **options)
+
+    def _apply_operator_JxKetCoupled(self, ket, **options):
+        return self._apply_op(ket, 'Jx', **options)
+
+    def _apply_operator_JyKet(self, ket, **options):
+        return self._apply_op(ket, 'Jy', **options)
+
+    def _apply_operator_JyKetCoupled(self, ket, **options):
+        return self._apply_op(ket, 'Jy', **options)
+
+    def _apply_operator_JzKet(self, ket, **options):
+        return self._apply_op(ket, 'Jz', **options)
+
+    def _apply_operator_JzKetCoupled(self, ket, **options):
+        return self._apply_op(ket, 'Jz', **options)
+
+    def _apply_operator_TensorProduct(self, tp, **options):
+        # Uncoupling operator is only easily found for coordinate basis spin operators
+        # TODO: add methods for uncoupling operators
+        if not isinstance(self, (JxOp, JyOp, JzOp)):
+            raise NotImplementedError
+        result = []
+        for n in range(len(tp.args)):
+            arg = []
+            arg.extend(tp.args[:n])
+            arg.append(self._apply_operator(tp.args[n]))
+            arg.extend(tp.args[n + 1:])
+            result.append(tp.__class__(*arg))
+        return Add(*result).expand()
+
+    # TODO: move this to qapply_Mul
+    def _apply_operator_Sum(self, s, **options):
+        new_func = qapply(self*s.function)
+        if new_func == self*s.function:
+            raise NotImplementedError
+        return Sum(new_func, *s.limits)
+
+    def _eval_trace(self, **options):
+        #TODO: use options to use different j values
+        #For now eval at default basis
+
+        # is it efficient to represent each time
+        # to do a trace?
+        return self._represent_default_basis().trace()
+
+
+class JplusOp(SpinOpBase, Operator):
+    """The J+ operator."""
+
+    _coord = '+'
+
+    basis = 'Jz'
+
+    def _eval_commutator_JminusOp(self, other):
+        return 2*hbar*JzOp(self.name)
+
+    def _apply_operator_JzKet(self, ket, **options):
+        j = ket.j
+        m = ket.m
+        if m.is_Number and j.is_Number:
+            if m >= j:
+                return S.Zero
+        return hbar*sqrt(j*(j + S.One) - m*(m + S.One))*JzKet(j, m + S.One)
+
+    def _apply_operator_JzKetCoupled(self, ket, **options):
+        j = ket.j
+        m = ket.m
+        jn = ket.jn
+        coupling = ket.coupling
+        if m.is_Number and j.is_Number:
+            if m >= j:
+                return S.Zero
+        return hbar*sqrt(j*(j + S.One) - m*(m + S.One))*JzKetCoupled(j, m + S.One, jn, coupling)
+
+    def matrix_element(self, j, m, jp, mp):
+        result = hbar*sqrt(j*(j + S.One) - mp*(mp + S.One))
+        result *= KroneckerDelta(m, mp + 1)
+        result *= KroneckerDelta(j, jp)
+        return result
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_base(basis, **options)
+
+    def _eval_rewrite_as_xyz(self, *args, **kwargs):
+        return JxOp(args[0]) + I*JyOp(args[0])
+
+
+class JminusOp(SpinOpBase, Operator):
+    """The J- operator."""
+
+    _coord = '-'
+
+    basis = 'Jz'
+
+    def _apply_operator_JzKet(self, ket, **options):
+        j = ket.j
+        m = ket.m
+        if m.is_Number and j.is_Number:
+            if m <= -j:
+                return S.Zero
+        return hbar*sqrt(j*(j + S.One) - m*(m - S.One))*JzKet(j, m - S.One)
+
+    def _apply_operator_JzKetCoupled(self, ket, **options):
+        j = ket.j
+        m = ket.m
+        jn = ket.jn
+        coupling = ket.coupling
+        if m.is_Number and j.is_Number:
+            if m <= -j:
+                return S.Zero
+        return hbar*sqrt(j*(j + S.One) - m*(m - S.One))*JzKetCoupled(j, m - S.One, jn, coupling)
+
+    def matrix_element(self, j, m, jp, mp):
+        result = hbar*sqrt(j*(j + S.One) - mp*(mp - S.One))
+        result *= KroneckerDelta(m, mp - 1)
+        result *= KroneckerDelta(j, jp)
+        return result
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_base(basis, **options)
+
+    def _eval_rewrite_as_xyz(self, *args, **kwargs):
+        return JxOp(args[0]) - I*JyOp(args[0])
+
+
+class JxOp(SpinOpBase, HermitianOperator):
+    """The Jx operator."""
+
+    _coord = 'x'
+
+    basis = 'Jx'
+
+    def _eval_commutator_JyOp(self, other):
+        return I*hbar*JzOp(self.name)
+
+    def _eval_commutator_JzOp(self, other):
+        return -I*hbar*JyOp(self.name)
+
+    def _apply_operator_JzKet(self, ket, **options):
+        jp = JplusOp(self.name)._apply_operator_JzKet(ket, **options)
+        jm = JminusOp(self.name)._apply_operator_JzKet(ket, **options)
+        return (jp + jm)/Integer(2)
+
+    def _apply_operator_JzKetCoupled(self, ket, **options):
+        jp = JplusOp(self.name)._apply_operator_JzKetCoupled(ket, **options)
+        jm = JminusOp(self.name)._apply_operator_JzKetCoupled(ket, **options)
+        return (jp + jm)/Integer(2)
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        jp = JplusOp(self.name)._represent_JzOp(basis, **options)
+        jm = JminusOp(self.name)._represent_JzOp(basis, **options)
+        return (jp + jm)/Integer(2)
+
+    def _eval_rewrite_as_plusminus(self, *args, **kwargs):
+        return (JplusOp(args[0]) + JminusOp(args[0]))/2
+
+
+class JyOp(SpinOpBase, HermitianOperator):
+    """The Jy operator."""
+
+    _coord = 'y'
+
+    basis = 'Jy'
+
+    def _eval_commutator_JzOp(self, other):
+        return I*hbar*JxOp(self.name)
+
+    def _eval_commutator_JxOp(self, other):
+        return -I*hbar*J2Op(self.name)
+
+    def _apply_operator_JzKet(self, ket, **options):
+        jp = JplusOp(self.name)._apply_operator_JzKet(ket, **options)
+        jm = JminusOp(self.name)._apply_operator_JzKet(ket, **options)
+        return (jp - jm)/(Integer(2)*I)
+
+    def _apply_operator_JzKetCoupled(self, ket, **options):
+        jp = JplusOp(self.name)._apply_operator_JzKetCoupled(ket, **options)
+        jm = JminusOp(self.name)._apply_operator_JzKetCoupled(ket, **options)
+        return (jp - jm)/(Integer(2)*I)
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        jp = JplusOp(self.name)._represent_JzOp(basis, **options)
+        jm = JminusOp(self.name)._represent_JzOp(basis, **options)
+        return (jp - jm)/(Integer(2)*I)
+
+    def _eval_rewrite_as_plusminus(self, *args, **kwargs):
+        return (JplusOp(args[0]) - JminusOp(args[0]))/(2*I)
+
+
+class JzOp(SpinOpBase, HermitianOperator):
+    """The Jz operator."""
+
+    _coord = 'z'
+
+    basis = 'Jz'
+
+    def _eval_commutator_JxOp(self, other):
+        return I*hbar*JyOp(self.name)
+
+    def _eval_commutator_JyOp(self, other):
+        return -I*hbar*JxOp(self.name)
+
+    def _eval_commutator_JplusOp(self, other):
+        return hbar*JplusOp(self.name)
+
+    def _eval_commutator_JminusOp(self, other):
+        return -hbar*JminusOp(self.name)
+
+    def matrix_element(self, j, m, jp, mp):
+        result = hbar*mp
+        result *= KroneckerDelta(m, mp)
+        result *= KroneckerDelta(j, jp)
+        return result
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_base(basis, **options)
+
+
+class J2Op(SpinOpBase, HermitianOperator):
+    """The J^2 operator."""
+
+    _coord = '2'
+
+    def _eval_commutator_JxOp(self, other):
+        return S.Zero
+
+    def _eval_commutator_JyOp(self, other):
+        return S.Zero
+
+    def _eval_commutator_JzOp(self, other):
+        return S.Zero
+
+    def _eval_commutator_JplusOp(self, other):
+        return S.Zero
+
+    def _eval_commutator_JminusOp(self, other):
+        return S.Zero
+
+    def _apply_operator_JxKet(self, ket, **options):
+        j = ket.j
+        return hbar**2*j*(j + 1)*ket
+
+    def _apply_operator_JxKetCoupled(self, ket, **options):
+        j = ket.j
+        return hbar**2*j*(j + 1)*ket
+
+    def _apply_operator_JyKet(self, ket, **options):
+        j = ket.j
+        return hbar**2*j*(j + 1)*ket
+
+    def _apply_operator_JyKetCoupled(self, ket, **options):
+        j = ket.j
+        return hbar**2*j*(j + 1)*ket
+
+    def _apply_operator_JzKet(self, ket, **options):
+        j = ket.j
+        return hbar**2*j*(j + 1)*ket
+
+    def _apply_operator_JzKetCoupled(self, ket, **options):
+        j = ket.j
+        return hbar**2*j*(j + 1)*ket
+
+    def matrix_element(self, j, m, jp, mp):
+        result = (hbar**2)*j*(j + 1)
+        result *= KroneckerDelta(m, mp)
+        result *= KroneckerDelta(j, jp)
+        return result
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_base(basis, **options)
+
+    def _print_contents_pretty(self, printer, *args):
+        a = prettyForm(str(self.name))
+        b = prettyForm('2')
+        return a**b
+
+    def _print_contents_latex(self, printer, *args):
+        return r'%s^2' % str(self.name)
+
+    def _eval_rewrite_as_xyz(self, *args, **kwargs):
+        return JxOp(args[0])**2 + JyOp(args[0])**2 + JzOp(args[0])**2
+
+    def _eval_rewrite_as_plusminus(self, *args, **kwargs):
+        a = args[0]
+        return JzOp(a)**2 + \
+            S.Half*(JplusOp(a)*JminusOp(a) + JminusOp(a)*JplusOp(a))
+
+
+class Rotation(UnitaryOperator):
+    """Wigner D operator in terms of Euler angles.
+
+    Defines the rotation operator in terms of the Euler angles defined by
+    the z-y-z convention for a passive transformation. That is the coordinate
+    axes are rotated first about the z-axis, giving the new x'-y'-z' axes. Then
+    this new coordinate system is rotated about the new y'-axis, giving new
+    x''-y''-z'' axes. Then this new coordinate system is rotated about the
+    z''-axis. Conventions follow those laid out in [1]_.
+
+    Parameters
+    ==========
+
+    alpha : Number, Symbol
+        First Euler Angle
+    beta : Number, Symbol
+        Second Euler angle
+    gamma : Number, Symbol
+        Third Euler angle
+
+    Examples
+    ========
+
+    A simple example rotation operator:
+
+        >>> from sympy import pi
+        >>> from sympy.physics.quantum.spin import Rotation
+        >>> Rotation(pi, 0, pi/2)
+        R(pi,0,pi/2)
+
+    With symbolic Euler angles and calculating the inverse rotation operator:
+
+        >>> from sympy import symbols
+        >>> a, b, c = symbols('a b c')
+        >>> Rotation(a, b, c)
+        R(a,b,c)
+        >>> Rotation(a, b, c).inverse()
+        R(-c,-b,-a)
+
+    See Also
+    ========
+
+    WignerD: Symbolic Wigner-D function
+    D: Wigner-D function
+    d: Wigner small-d function
+
+    References
+    ==========
+
+    .. [1] Varshalovich, D A, Quantum Theory of Angular Momentum. 1988.
+    """
+
+    @classmethod
+    def _eval_args(cls, args):
+        args = QExpr._eval_args(args)
+        if len(args) != 3:
+            raise ValueError('3 Euler angles required, got: %r' % args)
+        return args
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        # We consider all j values so our space is infinite.
+        return ComplexSpace(S.Infinity)
+
+    @property
+    def alpha(self):
+        return self.label[0]
+
+    @property
+    def beta(self):
+        return self.label[1]
+
+    @property
+    def gamma(self):
+        return self.label[2]
+
+    def _print_operator_name(self, printer, *args):
+        return 'R'
+
+    def _print_operator_name_pretty(self, printer, *args):
+        if printer._use_unicode:
+            return prettyForm('\N{SCRIPT CAPITAL R}' + ' ')
+        else:
+            return prettyForm("R ")
+
+    def _print_operator_name_latex(self, printer, *args):
+        return r'\mathcal{R}'
+
+    def _eval_inverse(self):
+        return Rotation(-self.gamma, -self.beta, -self.alpha)
+
+    @classmethod
+    def D(cls, j, m, mp, alpha, beta, gamma):
+        """Wigner D-function.
+
+        Returns an instance of the WignerD class corresponding to the Wigner-D
+        function specified by the parameters.
+
+        Parameters
+        ===========
+
+        j : Number
+            Total angular momentum
+        m : Number
+            Eigenvalue of angular momentum along axis after rotation
+        mp : Number
+            Eigenvalue of angular momentum along rotated axis
+        alpha : Number, Symbol
+            First Euler angle of rotation
+        beta : Number, Symbol
+            Second Euler angle of rotation
+        gamma : Number, Symbol
+            Third Euler angle of rotation
+
+        Examples
+        ========
+
+        Return the Wigner-D matrix element for a defined rotation, both
+        numerical and symbolic:
+
+            >>> from sympy.physics.quantum.spin import Rotation
+            >>> from sympy import pi, symbols
+            >>> alpha, beta, gamma = symbols('alpha beta gamma')
+            >>> Rotation.D(1, 1, 0,pi, pi/2,-pi)
+            WignerD(1, 1, 0, pi, pi/2, -pi)
+
+        See Also
+        ========
+
+        WignerD: Symbolic Wigner-D function
+
+        """
+        return WignerD(j, m, mp, alpha, beta, gamma)
+
+    @classmethod
+    def d(cls, j, m, mp, beta):
+        """Wigner small-d function.
+
+        Returns an instance of the WignerD class corresponding to the Wigner-D
+        function specified by the parameters with the alpha and gamma angles
+        given as 0.
+
+        Parameters
+        ===========
+
+        j : Number
+            Total angular momentum
+        m : Number
+            Eigenvalue of angular momentum along axis after rotation
+        mp : Number
+            Eigenvalue of angular momentum along rotated axis
+        beta : Number, Symbol
+            Second Euler angle of rotation
+
+        Examples
+        ========
+
+        Return the Wigner-D matrix element for a defined rotation, both
+        numerical and symbolic:
+
+            >>> from sympy.physics.quantum.spin import Rotation
+            >>> from sympy import pi, symbols
+            >>> beta = symbols('beta')
+            >>> Rotation.d(1, 1, 0, pi/2)
+            WignerD(1, 1, 0, 0, pi/2, 0)
+
+        See Also
+        ========
+
+        WignerD: Symbolic Wigner-D function
+
+        """
+        return WignerD(j, m, mp, 0, beta, 0)
+
+    def matrix_element(self, j, m, jp, mp):
+        result = self.__class__.D(
+            jp, m, mp, self.alpha, self.beta, self.gamma
+        )
+        result *= KroneckerDelta(j, jp)
+        return result
+
+    def _represent_base(self, basis, **options):
+        j = sympify(options.get('j', S.Half))
+        # TODO: move evaluation up to represent function/implement elsewhere
+        evaluate = sympify(options.get('doit'))
+        size, mvals = m_values(j)
+        result = zeros(size, size)
+        for p in range(size):
+            for q in range(size):
+                me = self.matrix_element(j, mvals[p], j, mvals[q])
+                if evaluate:
+                    result[p, q] = me.doit()
+                else:
+                    result[p, q] = me
+        return result
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_base(basis, **options)
+
+    def _apply_operator_uncoupled(self, state, ket, *, dummy=True, **options):
+        a = self.alpha
+        b = self.beta
+        g = self.gamma
+        j = ket.j
+        m = ket.m
+        if j.is_number:
+            s = []
+            size = m_values(j)
+            sz = size[1]
+            for mp in sz:
+                r = Rotation.D(j, m, mp, a, b, g)
+                z = r.doit()
+                s.append(z*state(j, mp))
+            return Add(*s)
+        else:
+            if dummy:
+                mp = Dummy('mp')
+            else:
+                mp = symbols('mp')
+            return Sum(Rotation.D(j, m, mp, a, b, g)*state(j, mp), (mp, -j, j))
+
+    def _apply_operator_JxKet(self, ket, **options):
+        return self._apply_operator_uncoupled(JxKet, ket, **options)
+
+    def _apply_operator_JyKet(self, ket, **options):
+        return self._apply_operator_uncoupled(JyKet, ket, **options)
+
+    def _apply_operator_JzKet(self, ket, **options):
+        return self._apply_operator_uncoupled(JzKet, ket, **options)
+
+    def _apply_operator_coupled(self, state, ket, *, dummy=True, **options):
+        a = self.alpha
+        b = self.beta
+        g = self.gamma
+        j = ket.j
+        m = ket.m
+        jn = ket.jn
+        coupling = ket.coupling
+        if j.is_number:
+            s = []
+            size = m_values(j)
+            sz = size[1]
+            for mp in sz:
+                r = Rotation.D(j, m, mp, a, b, g)
+                z = r.doit()
+                s.append(z*state(j, mp, jn, coupling))
+            return Add(*s)
+        else:
+            if dummy:
+                mp = Dummy('mp')
+            else:
+                mp = symbols('mp')
+            return Sum(Rotation.D(j, m, mp, a, b, g)*state(
+                j, mp, jn, coupling), (mp, -j, j))
+
+    def _apply_operator_JxKetCoupled(self, ket, **options):
+        return self._apply_operator_coupled(JxKetCoupled, ket, **options)
+
+    def _apply_operator_JyKetCoupled(self, ket, **options):
+        return self._apply_operator_coupled(JyKetCoupled, ket, **options)
+
+    def _apply_operator_JzKetCoupled(self, ket, **options):
+        return self._apply_operator_coupled(JzKetCoupled, ket, **options)
+
+class WignerD(Expr):
+    r"""Wigner-D function
+
+    The Wigner D-function gives the matrix elements of the rotation
+    operator in the jm-representation. For the Euler angles `\alpha`,
+    `\beta`, `\gamma`, the D-function is defined such that:
+
+    .. math ::
+        <j,m| \mathcal{R}(\alpha, \beta, \gamma ) |j',m'> = \delta_{jj'} D(j, m, m', \alpha, \beta, \gamma)
+
+    Where the rotation operator is as defined by the Rotation class [1]_.
+
+    The Wigner D-function defined in this way gives:
+
+    .. math ::
+        D(j, m, m', \alpha, \beta, \gamma) = e^{-i m \alpha} d(j, m, m', \beta) e^{-i m' \gamma}
+
+    Where d is the Wigner small-d function, which is given by Rotation.d.
+
+    The Wigner small-d function gives the component of the Wigner
+    D-function that is determined by the second Euler angle. That is the
+    Wigner D-function is:
+
+    .. math ::
+        D(j, m, m', \alpha, \beta, \gamma) = e^{-i m \alpha} d(j, m, m', \beta) e^{-i m' \gamma}
+
+    Where d is the small-d function. The Wigner D-function is given by
+    Rotation.D.
+
+    Note that to evaluate the D-function, the j, m and mp parameters must
+    be integer or half integer numbers.
+
+    Parameters
+    ==========
+
+    j : Number
+        Total angular momentum
+    m : Number
+        Eigenvalue of angular momentum along axis after rotation
+    mp : Number
+        Eigenvalue of angular momentum along rotated axis
+    alpha : Number, Symbol
+        First Euler angle of rotation
+    beta : Number, Symbol
+        Second Euler angle of rotation
+    gamma : Number, Symbol
+        Third Euler angle of rotation
+
+    Examples
+    ========
+
+    Evaluate the Wigner-D matrix elements of a simple rotation:
+
+        >>> from sympy.physics.quantum.spin import Rotation
+        >>> from sympy import pi
+        >>> rot = Rotation.D(1, 1, 0, pi, pi/2, 0)
+        >>> rot
+        WignerD(1, 1, 0, pi, pi/2, 0)
+        >>> rot.doit()
+        sqrt(2)/2
+
+    Evaluate the Wigner-d matrix elements of a simple rotation
+
+        >>> rot = Rotation.d(1, 1, 0, pi/2)
+        >>> rot
+        WignerD(1, 1, 0, 0, pi/2, 0)
+        >>> rot.doit()
+        -sqrt(2)/2
+
+    See Also
+    ========
+
+    Rotation: Rotation operator
+
+    References
+    ==========
+
+    .. [1] Varshalovich, D A, Quantum Theory of Angular Momentum. 1988.
+    """
+
+    is_commutative = True
+
+    def __new__(cls, *args, **hints):
+        if not len(args) == 6:
+            raise ValueError('6 parameters expected, got %s' % args)
+        args = sympify(args)
+        evaluate = hints.get('evaluate', False)
+        if evaluate:
+            return Expr.__new__(cls, *args)._eval_wignerd()
+        return Expr.__new__(cls, *args)
+
+    @property
+    def j(self):
+        return self.args[0]
+
+    @property
+    def m(self):
+        return self.args[1]
+
+    @property
+    def mp(self):
+        return self.args[2]
+
+    @property
+    def alpha(self):
+        return self.args[3]
+
+    @property
+    def beta(self):
+        return self.args[4]
+
+    @property
+    def gamma(self):
+        return self.args[5]
+
+    def _latex(self, printer, *args):
+        if self.alpha == 0 and self.gamma == 0:
+            return r'd^{%s}_{%s,%s}\left(%s\right)' % \
+                (
+                    printer._print(self.j), printer._print(
+                        self.m), printer._print(self.mp),
+                    printer._print(self.beta) )
+        return r'D^{%s}_{%s,%s}\left(%s,%s,%s\right)' % \
+            (
+                printer._print(
+                    self.j), printer._print(self.m), printer._print(self.mp),
+                printer._print(self.alpha), printer._print(self.beta), printer._print(self.gamma) )
+
+    def _pretty(self, printer, *args):
+        top = printer._print(self.j)
+
+        bot = printer._print(self.m)
+        bot = prettyForm(*bot.right(','))
+        bot = prettyForm(*bot.right(printer._print(self.mp)))
+
+        pad = max(top.width(), bot.width())
+        top = prettyForm(*top.left(' '))
+        bot = prettyForm(*bot.left(' '))
+        if pad > top.width():
+            top = prettyForm(*top.right(' '*(pad - top.width())))
+        if pad > bot.width():
+            bot = prettyForm(*bot.right(' '*(pad - bot.width())))
+        if self.alpha == 0 and self.gamma == 0:
+            args = printer._print(self.beta)
+            s = stringPict('d' + ' '*pad)
+        else:
+            args = printer._print(self.alpha)
+            args = prettyForm(*args.right(','))
+            args = prettyForm(*args.right(printer._print(self.beta)))
+            args = prettyForm(*args.right(','))
+            args = prettyForm(*args.right(printer._print(self.gamma)))
+
+            s = stringPict('D' + ' '*pad)
+
+        args = prettyForm(*args.parens())
+        s = prettyForm(*s.above(top))
+        s = prettyForm(*s.below(bot))
+        s = prettyForm(*s.right(args))
+        return s
+
+    def doit(self, **hints):
+        hints['evaluate'] = True
+        return WignerD(*self.args, **hints)
+
+    def _eval_wignerd(self):
+        j = self.j
+        m = self.m
+        mp = self.mp
+        alpha = self.alpha
+        beta = self.beta
+        gamma = self.gamma
+        if alpha == 0 and beta == 0 and gamma == 0:
+            return KroneckerDelta(m, mp)
+        if not j.is_number:
+            raise ValueError(
+                'j parameter must be numerical to evaluate, got %s' % j)
+        r = 0
+        if beta == pi/2:
+            # Varshalovich Equation (5), Section 4.16, page 113, setting
+            # alpha=gamma=0.
+            for k in range(2*j + 1):
+                if k > j + mp or k > j - m or k < mp - m:
+                    continue
+                r += (S.NegativeOne)**k*binomial(j + mp, k)*binomial(j - mp, k + m - mp)
+            r *= (S.NegativeOne)**(m - mp) / 2**j*sqrt(factorial(j + m) *
+                    factorial(j - m) / (factorial(j + mp)*factorial(j - mp)))
+        else:
+            # Varshalovich Equation(5), Section 4.7.2, page 87, where we set
+            # beta1=beta2=pi/2, and we get alpha=gamma=pi/2 and beta=phi+pi,
+            # then we use the Eq. (1), Section 4.4. page 79, to simplify:
+            # d(j, m, mp, beta+pi) = (-1)**(j-mp)*d(j, m, -mp, beta)
+            # This happens to be almost the same as in Eq.(10), Section 4.16,
+            # except that we need to substitute -mp for mp.
+            size, mvals = m_values(j)
+            for mpp in mvals:
+                r += Rotation.d(j, m, mpp, pi/2).doit()*(cos(-mpp*beta) + I*sin(-mpp*beta))*\
+                    Rotation.d(j, mpp, -mp, pi/2).doit()
+            # Empirical normalization factor so results match Varshalovich
+            # Tables 4.3-4.12
+            # Note that this exact normalization does not follow from the
+            # above equations
+            r = r*I**(2*j - m - mp)*(-1)**(2*m)
+            # Finally, simplify the whole expression
+            r = simplify(r)
+        r *= exp(-I*m*alpha)*exp(-I*mp*gamma)
+        return r
+
+
+Jx = JxOp('J')
+Jy = JyOp('J')
+Jz = JzOp('J')
+J2 = J2Op('J')
+Jplus = JplusOp('J')
+Jminus = JminusOp('J')
+
+
+#-----------------------------------------------------------------------------
+# Spin States
+#-----------------------------------------------------------------------------
+
+
+class SpinState(State):
+    """Base class for angular momentum states."""
+
+    _label_separator = ','
+
+    def __new__(cls, j, m):
+        j = sympify(j)
+        m = sympify(m)
+        if j.is_number:
+            if 2*j != int(2*j):
+                raise ValueError(
+                    'j must be integer or half-integer, got: %s' % j)
+            if j < 0:
+                raise ValueError('j must be >= 0, got: %s' % j)
+        if m.is_number:
+            if 2*m != int(2*m):
+                raise ValueError(
+                    'm must be integer or half-integer, got: %s' % m)
+        if j.is_number and m.is_number:
+            if abs(m) > j:
+                raise ValueError('Allowed values for m are -j <= m <= j, got j, m: %s, %s' % (j, m))
+            if int(j - m) != j - m:
+                raise ValueError('Both j and m must be integer or half-integer, got j, m: %s, %s' % (j, m))
+        return State.__new__(cls, j, m)
+
+    @property
+    def j(self):
+        return self.label[0]
+
+    @property
+    def m(self):
+        return self.label[1]
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        return ComplexSpace(2*label[0] + 1)
+
+    def _represent_base(self, **options):
+        j = self.j
+        m = self.m
+        alpha = sympify(options.get('alpha', 0))
+        beta = sympify(options.get('beta', 0))
+        gamma = sympify(options.get('gamma', 0))
+        size, mvals = m_values(j)
+        result = zeros(size, 1)
+        # breaks finding angles on L930
+        for p, mval in enumerate(mvals):
+            if m.is_number:
+                result[p, 0] = Rotation.D(
+                    self.j, mval, self.m, alpha, beta, gamma).doit()
+            else:
+                result[p, 0] = Rotation.D(self.j, mval,
+                                          self.m, alpha, beta, gamma)
+        return result
+
+    def _eval_rewrite_as_Jx(self, *args, **options):
+        if isinstance(self, Bra):
+            return self._rewrite_basis(Jx, JxBra, **options)
+        return self._rewrite_basis(Jx, JxKet, **options)
+
+    def _eval_rewrite_as_Jy(self, *args, **options):
+        if isinstance(self, Bra):
+            return self._rewrite_basis(Jy, JyBra, **options)
+        return self._rewrite_basis(Jy, JyKet, **options)
+
+    def _eval_rewrite_as_Jz(self, *args, **options):
+        if isinstance(self, Bra):
+            return self._rewrite_basis(Jz, JzBra, **options)
+        return self._rewrite_basis(Jz, JzKet, **options)
+
+    def _rewrite_basis(self, basis, evect, **options):
+        from sympy.physics.quantum.represent import represent
+        j = self.j
+        args = self.args[2:]
+        if j.is_number:
+            if isinstance(self, CoupledSpinState):
+                if j == int(j):
+                    start = j**2
+                else:
+                    start = (2*j - 1)*(2*j + 1)/4
+            else:
+                start = 0
+            vect = represent(self, basis=basis, **options)
+            result = Add(
+                *[vect[start + i]*evect(j, j - i, *args) for i in range(2*j + 1)])
+            if isinstance(self, CoupledSpinState) and options.get('coupled') is False:
+                return uncouple(result)
+            return result
+        else:
+            i = 0
+            mi = symbols('mi')
+            # make sure not to introduce a symbol already in the state
+            while self.subs(mi, 0) != self:
+                i += 1
+                mi = symbols('mi%d' % i)
+                break
+            # TODO: better way to get angles of rotation
+            if isinstance(self, CoupledSpinState):
+                test_args = (0, mi, (0, 0))
+            else:
+                test_args = (0, mi)
+            if isinstance(self, Ket):
+                angles = represent(
+                    self.__class__(*test_args), basis=basis)[0].args[3:6]
+            else:
+                angles = represent(self.__class__(
+                    *test_args), basis=basis)[0].args[0].args[3:6]
+            if angles == (0, 0, 0):
+                return self
+            else:
+                state = evect(j, mi, *args)
+                lt = Rotation.D(j, mi, self.m, *angles)
+                return Sum(lt*state, (mi, -j, j))
+
+    def _eval_innerproduct_JxBra(self, bra, **hints):
+        result = KroneckerDelta(self.j, bra.j)
+        if bra.dual_class() is not self.__class__:
+            result *= self._represent_JxOp(None)[bra.j - bra.m]
+        else:
+            result *= KroneckerDelta(
+                self.j, bra.j)*KroneckerDelta(self.m, bra.m)
+        return result
+
+    def _eval_innerproduct_JyBra(self, bra, **hints):
+        result = KroneckerDelta(self.j, bra.j)
+        if bra.dual_class() is not self.__class__:
+            result *= self._represent_JyOp(None)[bra.j - bra.m]
+        else:
+            result *= KroneckerDelta(
+                self.j, bra.j)*KroneckerDelta(self.m, bra.m)
+        return result
+
+    def _eval_innerproduct_JzBra(self, bra, **hints):
+        result = KroneckerDelta(self.j, bra.j)
+        if bra.dual_class() is not self.__class__:
+            result *= self._represent_JzOp(None)[bra.j - bra.m]
+        else:
+            result *= KroneckerDelta(
+                self.j, bra.j)*KroneckerDelta(self.m, bra.m)
+        return result
+
+    def _eval_trace(self, bra, **hints):
+
+        # One way to implement this method is to assume the basis set k is
+        # passed.
+        # Then we can apply the discrete form of Trace formula here
+        # Tr(|i><j| ) = \Sum_k <k|i><j|k>
+        #then we do qapply() on each each inner product and sum over them.
+
+        # OR
+
+        # Inner product of |i><j| = Trace(Outer Product).
+        # we could just use this unless there are cases when this is not true
+
+        return (bra*self).doit()
+
+
+class JxKet(SpinState, Ket):
+    """Eigenket of Jx.
+
+    See JzKet for the usage of spin eigenstates.
+
+    See Also
+    ========
+
+    JzKet: Usage of spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JxBra
+
+    @classmethod
+    def coupled_class(self):
+        return JxKetCoupled
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JxOp(None, **options)
+
+    def _represent_JxOp(self, basis, **options):
+        return self._represent_base(**options)
+
+    def _represent_JyOp(self, basis, **options):
+        return self._represent_base(alpha=pi*Rational(3, 2), **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_base(beta=pi/2, **options)
+
+
+class JxBra(SpinState, Bra):
+    """Eigenbra of Jx.
+
+    See JzKet for the usage of spin eigenstates.
+
+    See Also
+    ========
+
+    JzKet: Usage of spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JxKet
+
+    @classmethod
+    def coupled_class(self):
+        return JxBraCoupled
+
+
+class JyKet(SpinState, Ket):
+    """Eigenket of Jy.
+
+    See JzKet for the usage of spin eigenstates.
+
+    See Also
+    ========
+
+    JzKet: Usage of spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JyBra
+
+    @classmethod
+    def coupled_class(self):
+        return JyKetCoupled
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JyOp(None, **options)
+
+    def _represent_JxOp(self, basis, **options):
+        return self._represent_base(gamma=pi/2, **options)
+
+    def _represent_JyOp(self, basis, **options):
+        return self._represent_base(**options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_base(alpha=pi*Rational(3, 2), beta=-pi/2, gamma=pi/2, **options)
+
+
+class JyBra(SpinState, Bra):
+    """Eigenbra of Jy.
+
+    See JzKet for the usage of spin eigenstates.
+
+    See Also
+    ========
+
+    JzKet: Usage of spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JyKet
+
+    @classmethod
+    def coupled_class(self):
+        return JyBraCoupled
+
+
+class JzKet(SpinState, Ket):
+    """Eigenket of Jz.
+
+    Spin state which is an eigenstate of the Jz operator. Uncoupled states,
+    that is states representing the interaction of multiple separate spin
+    states, are defined as a tensor product of states.
+
+    Parameters
+    ==========
+
+    j : Number, Symbol
+        Total spin angular momentum
+    m : Number, Symbol
+        Eigenvalue of the Jz spin operator
+
+    Examples
+    ========
+
+    *Normal States:*
+
+    Defining simple spin states, both numerical and symbolic:
+
+        >>> from sympy.physics.quantum.spin import JzKet, JxKet
+        >>> from sympy import symbols
+        >>> JzKet(1, 0)
+        |1,0>
+        >>> j, m = symbols('j m')
+        >>> JzKet(j, m)
+        |j,m>
+
+    Rewriting the JzKet in terms of eigenkets of the Jx operator:
+    Note: that the resulting eigenstates are JxKet's
+
+        >>> JzKet(1,1).rewrite("Jx")
+        |1,-1>/2 - sqrt(2)*|1,0>/2 + |1,1>/2
+
+    Get the vector representation of a state in terms of the basis elements
+    of the Jx operator:
+
+        >>> from sympy.physics.quantum.represent import represent
+        >>> from sympy.physics.quantum.spin import Jx, Jz
+        >>> represent(JzKet(1,-1), basis=Jx)
+        Matrix([
+        [      1/2],
+        [sqrt(2)/2],
+        [      1/2]])
+
+    Apply innerproducts between states:
+
+        >>> from sympy.physics.quantum.innerproduct import InnerProduct
+        >>> from sympy.physics.quantum.spin import JxBra
+        >>> i = InnerProduct(JxBra(1,1), JzKet(1,1))
+        >>> i
+        <1,1|1,1>
+        >>> i.doit()
+        1/2
+
+    *Uncoupled States:*
+
+    Define an uncoupled state as a TensorProduct between two Jz eigenkets:
+
+        >>> from sympy.physics.quantum.tensorproduct import TensorProduct
+        >>> j1,m1,j2,m2 = symbols('j1 m1 j2 m2')
+        >>> TensorProduct(JzKet(1,0), JzKet(1,1))
+        |1,0>x|1,1>
+        >>> TensorProduct(JzKet(j1,m1), JzKet(j2,m2))
+        |j1,m1>x|j2,m2>
+
+    A TensorProduct can be rewritten, in which case the eigenstates that make
+    up the tensor product is rewritten to the new basis:
+
+        >>> TensorProduct(JzKet(1,1),JxKet(1,1)).rewrite('Jz')
+        |1,1>x|1,-1>/2 + sqrt(2)*|1,1>x|1,0>/2 + |1,1>x|1,1>/2
+
+    The represent method for TensorProduct's gives the vector representation of
+    the state. Note that the state in the product basis is the equivalent of the
+    tensor product of the vector representation of the component eigenstates:
+
+        >>> represent(TensorProduct(JzKet(1,0),JzKet(1,1)))
+        Matrix([
+        [0],
+        [0],
+        [0],
+        [1],
+        [0],
+        [0],
+        [0],
+        [0],
+        [0]])
+        >>> represent(TensorProduct(JzKet(1,1),JxKet(1,1)), basis=Jz)
+        Matrix([
+        [      1/2],
+        [sqrt(2)/2],
+        [      1/2],
+        [        0],
+        [        0],
+        [        0],
+        [        0],
+        [        0],
+        [        0]])
+
+    See Also
+    ========
+
+    JzKetCoupled: Coupled eigenstates
+    sympy.physics.quantum.tensorproduct.TensorProduct: Used to specify uncoupled states
+    uncouple: Uncouples states given coupling parameters
+    couple: Couples uncoupled states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JzBra
+
+    @classmethod
+    def coupled_class(self):
+        return JzKetCoupled
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JxOp(self, basis, **options):
+        return self._represent_base(beta=pi*Rational(3, 2), **options)
+
+    def _represent_JyOp(self, basis, **options):
+        return self._represent_base(alpha=pi*Rational(3, 2), beta=pi/2, gamma=pi/2, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_base(**options)
+
+
+class JzBra(SpinState, Bra):
+    """Eigenbra of Jz.
+
+    See the JzKet for the usage of spin eigenstates.
+
+    See Also
+    ========
+
+    JzKet: Usage of spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JzKet
+
+    @classmethod
+    def coupled_class(self):
+        return JzBraCoupled
+
+
+# Method used primarily to create coupled_n and coupled_jn by __new__ in
+# CoupledSpinState
+# This same method is also used by the uncouple method, and is separated from
+# the CoupledSpinState class to maintain consistency in defining coupling
+def _build_coupled(jcoupling, length):
+    n_list = [ [n + 1] for n in range(length) ]
+    coupled_jn = []
+    coupled_n = []
+    for n1, n2, j_new in jcoupling:
+        coupled_jn.append(j_new)
+        coupled_n.append( (n_list[n1 - 1], n_list[n2 - 1]) )
+        n_sort = sorted(n_list[n1 - 1] + n_list[n2 - 1])
+        n_list[n_sort[0] - 1] = n_sort
+    return coupled_n, coupled_jn
+
+
+class CoupledSpinState(SpinState):
+    """Base class for coupled angular momentum states."""
+
+    def __new__(cls, j, m, jn, *jcoupling):
+        # Check j and m values using SpinState
+        SpinState(j, m)
+        # Build and check coupling scheme from arguments
+        if len(jcoupling) == 0:
+            # Use default coupling scheme
+            jcoupling = []
+            for n in range(2, len(jn)):
+                jcoupling.append( (1, n, Add(*[jn[i] for i in range(n)])) )
+            jcoupling.append( (1, len(jn), j) )
+        elif len(jcoupling) == 1:
+            # Use specified coupling scheme
+            jcoupling = jcoupling[0]
+        else:
+            raise TypeError("CoupledSpinState only takes 3 or 4 arguments, got: %s" % (len(jcoupling) + 3) )
+        # Check arguments have correct form
+        if not isinstance(jn, (list, tuple, Tuple)):
+            raise TypeError('jn must be Tuple, list or tuple, got %s' %
+                            jn.__class__.__name__)
+        if not isinstance(jcoupling, (list, tuple, Tuple)):
+            raise TypeError('jcoupling must be Tuple, list or tuple, got %s' %
+                            jcoupling.__class__.__name__)
+        if not all(isinstance(term, (list, tuple, Tuple)) for term in jcoupling):
+            raise TypeError(
+                'All elements of jcoupling must be list, tuple or Tuple')
+        if not len(jn) - 1 == len(jcoupling):
+            raise ValueError('jcoupling must have length of %d, got %d' %
+                             (len(jn) - 1, len(jcoupling)))
+        if not all(len(x) == 3 for x in jcoupling):
+            raise ValueError('All elements of jcoupling must have length 3')
+        # Build sympified args
+        j = sympify(j)
+        m = sympify(m)
+        jn = Tuple( *[sympify(ji) for ji in jn] )
+        jcoupling = Tuple( *[Tuple(sympify(
+            n1), sympify(n2), sympify(ji)) for (n1, n2, ji) in jcoupling] )
+        # Check values in coupling scheme give physical state
+        if any(2*ji != int(2*ji) for ji in jn if ji.is_number):
+            raise ValueError('All elements of jn must be integer or half-integer, got: %s' % jn)
+        if any(n1 != int(n1) or n2 != int(n2) for (n1, n2, _) in jcoupling):
+            raise ValueError('Indices in jcoupling must be integers')
+        if any(n1 < 1 or n2 < 1 or n1 > len(jn) or n2 > len(jn) for (n1, n2, _) in jcoupling):
+            raise ValueError('Indices must be between 1 and the number of coupled spin spaces')
+        if any(2*ji != int(2*ji) for (_, _, ji) in jcoupling if ji.is_number):
+            raise ValueError('All coupled j values in coupling scheme must be integer or half-integer')
+        coupled_n, coupled_jn = _build_coupled(jcoupling, len(jn))
+        jvals = list(jn)
+        for n, (n1, n2) in enumerate(coupled_n):
+            j1 = jvals[min(n1) - 1]
+            j2 = jvals[min(n2) - 1]
+            j3 = coupled_jn[n]
+            if sympify(j1).is_number and sympify(j2).is_number and sympify(j3).is_number:
+                if j1 + j2 < j3:
+                    raise ValueError('All couplings must have j1+j2 >= j3, '
+                        'in coupling number %d got j1,j2,j3: %d,%d,%d' % (n + 1, j1, j2, j3))
+                if abs(j1 - j2) > j3:
+                    raise ValueError("All couplings must have |j1+j2| <= j3, "
+                        "in coupling number %d got j1,j2,j3: %d,%d,%d" % (n + 1, j1, j2, j3))
+                if int(j1 + j2) == j1 + j2:
+                    pass
+            jvals[min(n1 + n2) - 1] = j3
+        if len(jcoupling) > 0 and jcoupling[-1][2] != j:
+            raise ValueError('Last j value coupled together must be the final j of the state')
+        # Return state
+        return State.__new__(cls, j, m, jn, jcoupling)
+
+    def _print_label(self, printer, *args):
+        label = [printer._print(self.j), printer._print(self.m)]
+        for i, ji in enumerate(self.jn, start=1):
+            label.append('j%d=%s' % (
+                i, printer._print(ji)
+            ))
+        for jn, (n1, n2) in zip(self.coupled_jn[:-1], self.coupled_n[:-1]):
+            label.append('j(%s)=%s' % (
+                ','.join(str(i) for i in sorted(n1 + n2)), printer._print(jn)
+            ))
+        return ','.join(label)
+
+    def _print_label_pretty(self, printer, *args):
+        label = [self.j, self.m]
+        for i, ji in enumerate(self.jn, start=1):
+            symb = 'j%d' % i
+            symb = pretty_symbol(symb)
+            symb = prettyForm(symb + '=')
+            item = prettyForm(*symb.right(printer._print(ji)))
+            label.append(item)
+        for jn, (n1, n2) in zip(self.coupled_jn[:-1], self.coupled_n[:-1]):
+            n = ','.join(pretty_symbol("j%d" % i)[-1] for i in sorted(n1 + n2))
+            symb = prettyForm('j' + n + '=')
+            item = prettyForm(*symb.right(printer._print(jn)))
+            label.append(item)
+        return self._print_sequence_pretty(
+            label, self._label_separator, printer, *args
+        )
+
+    def _print_label_latex(self, printer, *args):
+        label = [
+            printer._print(self.j, *args),
+            printer._print(self.m, *args)
+        ]
+        for i, ji in enumerate(self.jn, start=1):
+            label.append('j_{%d}=%s' % (i, printer._print(ji, *args)) )
+        for jn, (n1, n2) in zip(self.coupled_jn[:-1], self.coupled_n[:-1]):
+            n = ','.join(str(i) for i in sorted(n1 + n2))
+            label.append('j_{%s}=%s' % (n, printer._print(jn, *args)) )
+        return self._label_separator.join(label)
+
+    @property
+    def jn(self):
+        return self.label[2]
+
+    @property
+    def coupling(self):
+        return self.label[3]
+
+    @property
+    def coupled_jn(self):
+        return _build_coupled(self.label[3], len(self.label[2]))[1]
+
+    @property
+    def coupled_n(self):
+        return _build_coupled(self.label[3], len(self.label[2]))[0]
+
+    @classmethod
+    def _eval_hilbert_space(cls, label):
+        j = Add(*label[2])
+        if j.is_number:
+            return DirectSumHilbertSpace(*[ ComplexSpace(x) for x in range(int(2*j + 1), 0, -2) ])
+        else:
+            # TODO: Need hilbert space fix, see issue 5732
+            # Desired behavior:
+            #ji = symbols('ji')
+            #ret = Sum(ComplexSpace(2*ji + 1), (ji, 0, j))
+            # Temporary fix:
+            return ComplexSpace(2*j + 1)
+
+    def _represent_coupled_base(self, **options):
+        evect = self.uncoupled_class()
+        if not self.j.is_number:
+            raise ValueError(
+                'State must not have symbolic j value to represent')
+        if not self.hilbert_space.dimension.is_number:
+            raise ValueError(
+                'State must not have symbolic j values to represent')
+        result = zeros(self.hilbert_space.dimension, 1)
+        if self.j == int(self.j):
+            start = self.j**2
+        else:
+            start = (2*self.j - 1)*(1 + 2*self.j)/4
+        result[start:start + 2*self.j + 1, 0] = evect(
+            self.j, self.m)._represent_base(**options)
+        return result
+
+    def _eval_rewrite_as_Jx(self, *args, **options):
+        if isinstance(self, Bra):
+            return self._rewrite_basis(Jx, JxBraCoupled, **options)
+        return self._rewrite_basis(Jx, JxKetCoupled, **options)
+
+    def _eval_rewrite_as_Jy(self, *args, **options):
+        if isinstance(self, Bra):
+            return self._rewrite_basis(Jy, JyBraCoupled, **options)
+        return self._rewrite_basis(Jy, JyKetCoupled, **options)
+
+    def _eval_rewrite_as_Jz(self, *args, **options):
+        if isinstance(self, Bra):
+            return self._rewrite_basis(Jz, JzBraCoupled, **options)
+        return self._rewrite_basis(Jz, JzKetCoupled, **options)
+
+
+class JxKetCoupled(CoupledSpinState, Ket):
+    """Coupled eigenket of Jx.
+
+    See JzKetCoupled for the usage of coupled spin eigenstates.
+
+    See Also
+    ========
+
+    JzKetCoupled: Usage of coupled spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JxBraCoupled
+
+    @classmethod
+    def uncoupled_class(self):
+        return JxKet
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JxOp(self, basis, **options):
+        return self._represent_coupled_base(**options)
+
+    def _represent_JyOp(self, basis, **options):
+        return self._represent_coupled_base(alpha=pi*Rational(3, 2), **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_coupled_base(beta=pi/2, **options)
+
+
+class JxBraCoupled(CoupledSpinState, Bra):
+    """Coupled eigenbra of Jx.
+
+    See JzKetCoupled for the usage of coupled spin eigenstates.
+
+    See Also
+    ========
+
+    JzKetCoupled: Usage of coupled spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JxKetCoupled
+
+    @classmethod
+    def uncoupled_class(self):
+        return JxBra
+
+
+class JyKetCoupled(CoupledSpinState, Ket):
+    """Coupled eigenket of Jy.
+
+    See JzKetCoupled for the usage of coupled spin eigenstates.
+
+    See Also
+    ========
+
+    JzKetCoupled: Usage of coupled spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JyBraCoupled
+
+    @classmethod
+    def uncoupled_class(self):
+        return JyKet
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JxOp(self, basis, **options):
+        return self._represent_coupled_base(gamma=pi/2, **options)
+
+    def _represent_JyOp(self, basis, **options):
+        return self._represent_coupled_base(**options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_coupled_base(alpha=pi*Rational(3, 2), beta=-pi/2, gamma=pi/2, **options)
+
+
+class JyBraCoupled(CoupledSpinState, Bra):
+    """Coupled eigenbra of Jy.
+
+    See JzKetCoupled for the usage of coupled spin eigenstates.
+
+    See Also
+    ========
+
+    JzKetCoupled: Usage of coupled spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JyKetCoupled
+
+    @classmethod
+    def uncoupled_class(self):
+        return JyBra
+
+
+class JzKetCoupled(CoupledSpinState, Ket):
+    r"""Coupled eigenket of Jz
+
+    Spin state that is an eigenket of Jz which represents the coupling of
+    separate spin spaces.
+
+    The arguments for creating instances of JzKetCoupled are ``j``, ``m``,
+    ``jn`` and an optional ``jcoupling`` argument. The ``j`` and ``m`` options
+    are the total angular momentum quantum numbers, as used for normal states
+    (e.g. JzKet).
+
+    The other required parameter in ``jn``, which is a tuple defining the `j_n`
+    angular momentum quantum numbers of the product spaces. So for example, if
+    a state represented the coupling of the product basis state
+    `\left|j_1,m_1\right\rangle\times\left|j_2,m_2\right\rangle`, the ``jn``
+    for this state would be ``(j1,j2)``.
+
+    The final option is ``jcoupling``, which is used to define how the spaces
+    specified by ``jn`` are coupled, which includes both the order these spaces
+    are coupled together and the quantum numbers that arise from these
+    couplings. The ``jcoupling`` parameter itself is a list of lists, such that
+    each of the sublists defines a single coupling between the spin spaces. If
+    there are N coupled angular momentum spaces, that is ``jn`` has N elements,
+    then there must be N-1 sublists. Each of these sublists making up the
+    ``jcoupling`` parameter have length 3. The first two elements are the
+    indices of the product spaces that are considered to be coupled together.
+    For example, if we want to couple `j_1` and `j_4`, the indices would be 1
+    and 4. If a state has already been coupled, it is referenced by the
+    smallest index that is coupled, so if `j_2` and `j_4` has already been
+    coupled to some `j_{24}`, then this value can be coupled by referencing it
+    with index 2. The final element of the sublist is the quantum number of the
+    coupled state. So putting everything together, into a valid sublist for
+    ``jcoupling``, if `j_1` and `j_2` are coupled to an angular momentum space
+    with quantum number `j_{12}` with the value ``j12``, the sublist would be
+    ``(1,2,j12)``, N-1 of these sublists are used in the list for
+    ``jcoupling``.
+
+    Note the ``jcoupling`` parameter is optional, if it is not specified, the
+    default coupling is taken. This default value is to coupled the spaces in
+    order and take the quantum number of the coupling to be the maximum value.
+    For example, if the spin spaces are `j_1`, `j_2`, `j_3`, `j_4`, then the
+    default coupling couples `j_1` and `j_2` to `j_{12}=j_1+j_2`, then,
+    `j_{12}` and `j_3` are coupled to `j_{123}=j_{12}+j_3`, and finally
+    `j_{123}` and `j_4` to `j=j_{123}+j_4`. The jcoupling value that would
+    correspond to this is:
+
+        ``((1,2,j1+j2),(1,3,j1+j2+j3))``
+
+    Parameters
+    ==========
+
+    args : tuple
+        The arguments that must be passed are ``j``, ``m``, ``jn``, and
+        ``jcoupling``. The ``j`` value is the total angular momentum. The ``m``
+        value is the eigenvalue of the Jz spin operator. The ``jn`` list are
+        the j values of argular momentum spaces coupled together. The
+        ``jcoupling`` parameter is an optional parameter defining how the spaces
+        are coupled together. See the above description for how these coupling
+        parameters are defined.
+
+    Examples
+    ========
+
+    Defining simple spin states, both numerical and symbolic:
+
+        >>> from sympy.physics.quantum.spin import JzKetCoupled
+        >>> from sympy import symbols
+        >>> JzKetCoupled(1, 0, (1, 1))
+        |1,0,j1=1,j2=1>
+        >>> j, m, j1, j2 = symbols('j m j1 j2')
+        >>> JzKetCoupled(j, m, (j1, j2))
+        |j,m,j1=j1,j2=j2>
+
+    Defining coupled spin states for more than 2 coupled spaces with various
+    coupling parameters:
+
+        >>> JzKetCoupled(2, 1, (1, 1, 1))
+        |2,1,j1=1,j2=1,j3=1,j(1,2)=2>
+        >>> JzKetCoupled(2, 1, (1, 1, 1), ((1,2,2),(1,3,2)) )
+        |2,1,j1=1,j2=1,j3=1,j(1,2)=2>
+        >>> JzKetCoupled(2, 1, (1, 1, 1), ((2,3,1),(1,2,2)) )
+        |2,1,j1=1,j2=1,j3=1,j(2,3)=1>
+
+    Rewriting the JzKetCoupled in terms of eigenkets of the Jx operator:
+    Note: that the resulting eigenstates are JxKetCoupled
+
+        >>> JzKetCoupled(1,1,(1,1)).rewrite("Jx")
+        |1,-1,j1=1,j2=1>/2 - sqrt(2)*|1,0,j1=1,j2=1>/2 + |1,1,j1=1,j2=1>/2
+
+    The rewrite method can be used to convert a coupled state to an uncoupled
+    state. This is done by passing coupled=False to the rewrite function:
+
+        >>> JzKetCoupled(1, 0, (1, 1)).rewrite('Jz', coupled=False)
+        -sqrt(2)*|1,-1>x|1,1>/2 + sqrt(2)*|1,1>x|1,-1>/2
+
+    Get the vector representation of a state in terms of the basis elements
+    of the Jx operator:
+
+        >>> from sympy.physics.quantum.represent import represent
+        >>> from sympy.physics.quantum.spin import Jx
+        >>> from sympy import S
+        >>> represent(JzKetCoupled(1,-1,(S(1)/2,S(1)/2)), basis=Jx)
+        Matrix([
+        [        0],
+        [      1/2],
+        [sqrt(2)/2],
+        [      1/2]])
+
+    See Also
+    ========
+
+    JzKet: Normal spin eigenstates
+    uncouple: Uncoupling of coupling spin states
+    couple: Coupling of uncoupled spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JzBraCoupled
+
+    @classmethod
+    def uncoupled_class(self):
+        return JzKet
+
+    def _represent_default_basis(self, **options):
+        return self._represent_JzOp(None, **options)
+
+    def _represent_JxOp(self, basis, **options):
+        return self._represent_coupled_base(beta=pi*Rational(3, 2), **options)
+
+    def _represent_JyOp(self, basis, **options):
+        return self._represent_coupled_base(alpha=pi*Rational(3, 2), beta=pi/2, gamma=pi/2, **options)
+
+    def _represent_JzOp(self, basis, **options):
+        return self._represent_coupled_base(**options)
+
+
+class JzBraCoupled(CoupledSpinState, Bra):
+    """Coupled eigenbra of Jz.
+
+    See the JzKetCoupled for the usage of coupled spin eigenstates.
+
+    See Also
+    ========
+
+    JzKetCoupled: Usage of coupled spin states
+
+    """
+
+    @classmethod
+    def dual_class(self):
+        return JzKetCoupled
+
+    @classmethod
+    def uncoupled_class(self):
+        return JzBra
+
+#-----------------------------------------------------------------------------
+# Coupling/uncoupling
+#-----------------------------------------------------------------------------
+
+
+def couple(expr, jcoupling_list=None):
+    """ Couple a tensor product of spin states
+
+    This function can be used to couple an uncoupled tensor product of spin
+    states. All of the eigenstates to be coupled must be of the same class. It
+    will return a linear combination of eigenstates that are subclasses of
+    CoupledSpinState determined by Clebsch-Gordan angular momentum coupling
+    coefficients.
+
+    Parameters
+    ==========
+
+    expr : Expr
+        An expression involving TensorProducts of spin states to be coupled.
+        Each state must be a subclass of SpinState and they all must be the
+        same class.
+
+    jcoupling_list : list or tuple
+        Elements of this list are sub-lists of length 2 specifying the order of
+        the coupling of the spin spaces. The length of this must be N-1, where N
+        is the number of states in the tensor product to be coupled. The
+        elements of this sublist are the same as the first two elements of each
+        sublist in the ``jcoupling`` parameter defined for JzKetCoupled. If this
+        parameter is not specified, the default value is taken, which couples
+        the first and second product basis spaces, then couples this new coupled
+        space to the third product space, etc
+
+    Examples
+    ========
+
+    Couple a tensor product of numerical states for two spaces:
+
+        >>> from sympy.physics.quantum.spin import JzKet, couple
+        >>> from sympy.physics.quantum.tensorproduct import TensorProduct
+        >>> couple(TensorProduct(JzKet(1,0), JzKet(1,1)))
+        -sqrt(2)*|1,1,j1=1,j2=1>/2 + sqrt(2)*|2,1,j1=1,j2=1>/2
+
+
+    Numerical coupling of three spaces using the default coupling method, i.e.
+    first and second spaces couple, then this couples to the third space:
+
+        >>> couple(TensorProduct(JzKet(1,1), JzKet(1,1), JzKet(1,0)))
+        sqrt(6)*|2,2,j1=1,j2=1,j3=1,j(1,2)=2>/3 + sqrt(3)*|3,2,j1=1,j2=1,j3=1,j(1,2)=2>/3
+
+    Perform this same coupling, but we define the coupling to first couple
+    the first and third spaces:
+
+        >>> couple(TensorProduct(JzKet(1,1), JzKet(1,1), JzKet(1,0)), ((1,3),(1,2)) )
+        sqrt(2)*|2,2,j1=1,j2=1,j3=1,j(1,3)=1>/2 - sqrt(6)*|2,2,j1=1,j2=1,j3=1,j(1,3)=2>/6 + sqrt(3)*|3,2,j1=1,j2=1,j3=1,j(1,3)=2>/3
+
+    Couple a tensor product of symbolic states:
+
+        >>> from sympy import symbols
+        >>> j1,m1,j2,m2 = symbols('j1 m1 j2 m2')
+        >>> couple(TensorProduct(JzKet(j1,m1), JzKet(j2,m2)))
+        Sum(CG(j1, m1, j2, m2, j, m1 + m2)*|j,m1 + m2,j1=j1,j2=j2>, (j, m1 + m2, j1 + j2))
+
+    """
+    a = expr.atoms(TensorProduct)
+    for tp in a:
+        # Allow other tensor products to be in expression
+        if not all(isinstance(state, SpinState) for state in tp.args):
+            continue
+        # If tensor product has all spin states, raise error for invalid tensor product state
+        if not all(state.__class__ is tp.args[0].__class__ for state in tp.args):
+            raise TypeError('All states must be the same basis')
+        expr = expr.subs(tp, _couple(tp, jcoupling_list))
+    return expr
+
+
+def _couple(tp, jcoupling_list):
+    states = tp.args
+    coupled_evect = states[0].coupled_class()
+
+    # Define default coupling if none is specified
+    if jcoupling_list is None:
+        jcoupling_list = []
+        for n in range(1, len(states)):
+            jcoupling_list.append( (1, n + 1) )
+
+    # Check jcoupling_list valid
+    if not len(jcoupling_list) == len(states) - 1:
+        raise TypeError('jcoupling_list must be length %d, got %d' %
+                        (len(states) - 1, len(jcoupling_list)))
+    if not all( len(coupling) == 2 for coupling in jcoupling_list):
+        raise ValueError('Each coupling must define 2 spaces')
+    if any(n1 == n2 for n1, n2 in jcoupling_list):
+        raise ValueError('Spin spaces cannot couple to themselves')
+    if all(sympify(n1).is_number and sympify(n2).is_number for n1, n2 in jcoupling_list):
+        j_test = [0]*len(states)
+        for n1, n2 in jcoupling_list:
+            if j_test[n1 - 1] == -1 or j_test[n2 - 1] == -1:
+                raise ValueError('Spaces coupling j_n\'s are referenced by smallest n value')
+            j_test[max(n1, n2) - 1] = -1
+
+    # j values of states to be coupled together
+    jn = [state.j for state in states]
+    mn = [state.m for state in states]
+
+    # Create coupling_list, which defines all the couplings between all
+    # the spaces from jcoupling_list
+    coupling_list = []
+    n_list = [ [i + 1] for i in range(len(states)) ]
+    for j_coupling in jcoupling_list:
+        # Least n for all j_n which is coupled as first and second spaces
+        n1, n2 = j_coupling
+        # List of all n's coupled in first and second spaces
+        j1_n = list(n_list[n1 - 1])
+        j2_n = list(n_list[n2 - 1])
+        coupling_list.append( (j1_n, j2_n) )
+        # Set new j_n to be coupling of all j_n in both first and second spaces
+        n_list[ min(n1, n2) - 1 ] = sorted(j1_n + j2_n)
+
+    if all(state.j.is_number and state.m.is_number for state in states):
+        # Numerical coupling
+        # Iterate over difference between maximum possible j value of each coupling and the actual value
+        diff_max = [ Add( *[ jn[n - 1] - mn[n - 1] for n in coupling[0] +
+                         coupling[1] ] ) for coupling in coupling_list ]
+        result = []
+        for diff in range(diff_max[-1] + 1):
+            # Determine available configurations
+            n = len(coupling_list)
+            tot = binomial(diff + n - 1, diff)
+
+            for config_num in range(tot):
+                diff_list = _confignum_to_difflist(config_num, diff, n)
+
+                # Skip the configuration if non-physical
+                # This is a lazy check for physical states given the loose restrictions of diff_max
+                if any(d > m for d, m in zip(diff_list, diff_max)):
+                    continue
+
+                # Determine term
+                cg_terms = []
+                coupled_j = list(jn)
+                jcoupling = []
+                for (j1_n, j2_n), coupling_diff in zip(coupling_list, diff_list):
+                    j1 = coupled_j[ min(j1_n) - 1 ]
+                    j2 = coupled_j[ min(j2_n) - 1 ]
+                    j3 = j1 + j2 - coupling_diff
+                    coupled_j[ min(j1_n + j2_n) - 1 ] = j3
+                    m1 = Add( *[ mn[x - 1] for x in j1_n] )
+                    m2 = Add( *[ mn[x - 1] for x in j2_n] )
+                    m3 = m1 + m2
+                    cg_terms.append( (j1, m1, j2, m2, j3, m3) )
+                    jcoupling.append( (min(j1_n), min(j2_n), j3) )
+                # Better checks that state is physical
+                if any(abs(term[5]) > term[4] for term in cg_terms):
+                    continue
+                if any(term[0] + term[2] < term[4] for term in cg_terms):
+                    continue
+                if any(abs(term[0] - term[2]) > term[4] for term in cg_terms):
+                    continue
+                coeff = Mul( *[ CG(*term).doit() for term in cg_terms] )
+                state = coupled_evect(j3, m3, jn, jcoupling)
+                result.append(coeff*state)
+        return Add(*result)
+    else:
+        # Symbolic coupling
+        cg_terms = []
+        jcoupling = []
+        sum_terms = []
+        coupled_j = list(jn)
+        for j1_n, j2_n in coupling_list:
+            j1 = coupled_j[ min(j1_n) - 1 ]
+            j2 = coupled_j[ min(j2_n) - 1 ]
+            if len(j1_n + j2_n) == len(states):
+                j3 = symbols('j')
+            else:
+                j3_name = 'j' + ''.join(["%s" % n for n in j1_n + j2_n])
+                j3 = symbols(j3_name)
+            coupled_j[ min(j1_n + j2_n) - 1 ] = j3
+            m1 = Add( *[ mn[x - 1] for x in j1_n] )
+            m2 = Add( *[ mn[x - 1] for x in j2_n] )
+            m3 = m1 + m2
+            cg_terms.append( (j1, m1, j2, m2, j3, m3) )
+            jcoupling.append( (min(j1_n), min(j2_n), j3) )
+            sum_terms.append((j3, m3, j1 + j2))
+        coeff = Mul( *[ CG(*term) for term in cg_terms] )
+        state = coupled_evect(j3, m3, jn, jcoupling)
+        return Sum(coeff*state, *sum_terms)
+
+
+def uncouple(expr, jn=None, jcoupling_list=None):
+    """ Uncouple a coupled spin state
+
+    Gives the uncoupled representation of a coupled spin state. Arguments must
+    be either a spin state that is a subclass of CoupledSpinState or a spin
+    state that is a subclass of SpinState and an array giving the j values
+    of the spaces that are to be coupled
+
+    Parameters
+    ==========
+
+    expr : Expr
+        The expression containing states that are to be coupled. If the states
+        are a subclass of SpinState, the ``jn`` and ``jcoupling`` parameters
+        must be defined. If the states are a subclass of CoupledSpinState,
+        ``jn`` and ``jcoupling`` will be taken from the state.
+
+    jn : list or tuple
+        The list of the j-values that are coupled. If state is a
+        CoupledSpinState, this parameter is ignored. This must be defined if
+        state is not a subclass of CoupledSpinState. The syntax of this
+        parameter is the same as the ``jn`` parameter of JzKetCoupled.
+
+    jcoupling_list : list or tuple
+        The list defining how the j-values are coupled together. If state is a
+        CoupledSpinState, this parameter is ignored. This must be defined if
+        state is not a subclass of CoupledSpinState. The syntax of this
+        parameter is the same as the ``jcoupling`` parameter of JzKetCoupled.
+
+    Examples
+    ========
+
+    Uncouple a numerical state using a CoupledSpinState state:
+
+        >>> from sympy.physics.quantum.spin import JzKetCoupled, uncouple
+        >>> from sympy import S
+        >>> uncouple(JzKetCoupled(1, 0, (S(1)/2, S(1)/2)))
+        sqrt(2)*|1/2,-1/2>x|1/2,1/2>/2 + sqrt(2)*|1/2,1/2>x|1/2,-1/2>/2
+
+    Perform the same calculation using a SpinState state:
+
+        >>> from sympy.physics.quantum.spin import JzKet
+        >>> uncouple(JzKet(1, 0), (S(1)/2, S(1)/2))
+        sqrt(2)*|1/2,-1/2>x|1/2,1/2>/2 + sqrt(2)*|1/2,1/2>x|1/2,-1/2>/2
+
+    Uncouple a numerical state of three coupled spaces using a CoupledSpinState state:
+
+        >>> uncouple(JzKetCoupled(1, 1, (1, 1, 1), ((1,3,1),(1,2,1)) ))
+        |1,-1>x|1,1>x|1,1>/2 - |1,0>x|1,0>x|1,1>/2 + |1,1>x|1,0>x|1,0>/2 - |1,1>x|1,1>x|1,-1>/2
+
+    Perform the same calculation using a SpinState state:
+
+        >>> uncouple(JzKet(1, 1), (1, 1, 1), ((1,3,1),(1,2,1)) )
+        |1,-1>x|1,1>x|1,1>/2 - |1,0>x|1,0>x|1,1>/2 + |1,1>x|1,0>x|1,0>/2 - |1,1>x|1,1>x|1,-1>/2
+
+    Uncouple a symbolic state using a CoupledSpinState state:
+
+        >>> from sympy import symbols
+        >>> j,m,j1,j2 = symbols('j m j1 j2')
+        >>> uncouple(JzKetCoupled(j, m, (j1, j2)))
+        Sum(CG(j1, m1, j2, m2, j, m)*|j1,m1>x|j2,m2>, (m1, -j1, j1), (m2, -j2, j2))
+
+    Perform the same calculation using a SpinState state
+
+        >>> uncouple(JzKet(j, m), (j1, j2))
+        Sum(CG(j1, m1, j2, m2, j, m)*|j1,m1>x|j2,m2>, (m1, -j1, j1), (m2, -j2, j2))
+
+    """
+    a = expr.atoms(SpinState)
+    for state in a:
+        expr = expr.subs(state, _uncouple(state, jn, jcoupling_list))
+    return expr
+
+
+def _uncouple(state, jn, jcoupling_list):
+    if isinstance(state, CoupledSpinState):
+        jn = state.jn
+        coupled_n = state.coupled_n
+        coupled_jn = state.coupled_jn
+        evect = state.uncoupled_class()
+    elif isinstance(state, SpinState):
+        if jn is None:
+            raise ValueError("Must specify j-values for coupled state")
+        if not isinstance(jn, (list, tuple)):
+            raise TypeError("jn must be list or tuple")
+        if jcoupling_list is None:
+            # Use default
+            jcoupling_list = []
+            for i in range(1, len(jn)):
+                jcoupling_list.append(
+                    (1, 1 + i, Add(*[jn[j] for j in range(i + 1)])) )
+        if not isinstance(jcoupling_list, (list, tuple)):
+            raise TypeError("jcoupling must be a list or tuple")
+        if not len(jcoupling_list) == len(jn) - 1:
+            raise ValueError("Must specify 2 fewer coupling terms than the number of j values")
+        coupled_n, coupled_jn = _build_coupled(jcoupling_list, len(jn))
+        evect = state.__class__
+    else:
+        raise TypeError("state must be a spin state")
+    j = state.j
+    m = state.m
+    coupling_list = []
+    j_list = list(jn)
+
+    # Create coupling, which defines all the couplings between all the spaces
+    for j3, (n1, n2) in zip(coupled_jn, coupled_n):
+        # j's which are coupled as first and second spaces
+        j1 = j_list[n1[0] - 1]
+        j2 = j_list[n2[0] - 1]
+        # Build coupling list
+        coupling_list.append( (n1, n2, j1, j2, j3) )
+        # Set new value in j_list
+        j_list[min(n1 + n2) - 1] = j3
+
+    if j.is_number and m.is_number:
+        diff_max = [ 2*x for x in jn ]
+        diff = Add(*jn) - m
+
+        n = len(jn)
+        tot = binomial(diff + n - 1, diff)
+
+        result = []
+        for config_num in range(tot):
+            diff_list = _confignum_to_difflist(config_num, diff, n)
+            if any(d > p for d, p in zip(diff_list, diff_max)):
+                continue
+
+            cg_terms = []
+            for coupling in coupling_list:
+                j1_n, j2_n, j1, j2, j3 = coupling
+                m1 = Add( *[ jn[x - 1] - diff_list[x - 1] for x in j1_n ] )
+                m2 = Add( *[ jn[x - 1] - diff_list[x - 1] for x in j2_n ] )
+                m3 = m1 + m2
+                cg_terms.append( (j1, m1, j2, m2, j3, m3) )
+            coeff = Mul( *[ CG(*term).doit() for term in cg_terms ] )
+            state = TensorProduct(
+                *[ evect(j, j - d) for j, d in zip(jn, diff_list) ] )
+            result.append(coeff*state)
+        return Add(*result)
+    else:
+        # Symbolic coupling
+        m_str = "m1:%d" % (len(jn) + 1)
+        mvals = symbols(m_str)
+        cg_terms = [(j1, Add(*[mvals[n - 1] for n in j1_n]),
+                     j2, Add(*[mvals[n - 1] for n in j2_n]),
+                     j3, Add(*[mvals[n - 1] for n in j1_n + j2_n])) for j1_n, j2_n, j1, j2, j3 in coupling_list[:-1] ]
+        cg_terms.append(*[(j1, Add(*[mvals[n - 1] for n in j1_n]),
+                           j2, Add(*[mvals[n - 1] for n in j2_n]),
+                           j, m) for j1_n, j2_n, j1, j2, j3 in [coupling_list[-1]] ])
+        cg_coeff = Mul(*[CG(*cg_term) for cg_term in cg_terms])
+        sum_terms = [ (m, -j, j) for j, m in zip(jn, mvals) ]
+        state = TensorProduct( *[ evect(j, m) for j, m in zip(jn, mvals) ] )
+        return Sum(cg_coeff*state, *sum_terms)
+
+
+def _confignum_to_difflist(config_num, diff, list_len):
+    # Determines configuration of diffs into list_len number of slots
+    diff_list = []
+    for n in range(list_len):
+        prev_diff = diff
+        # Number of spots after current one
+        rem_spots = list_len - n - 1
+        # Number of configurations of distributing diff among the remaining spots
+        rem_configs = binomial(diff + rem_spots - 1, diff)
+        while config_num >= rem_configs:
+            config_num -= rem_configs
+            diff -= 1
+            rem_configs = binomial(diff + rem_spots - 1, diff)
+        diff_list.append(prev_diff - diff)
+    return diff_list

venv/lib/python3.10/site-packages/sympy/physics/quantum/state.py

@@ -0,0 +1,1014 @@
+"""Dirac notation for states."""
+
+from sympy.core.cache import cacheit
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import Function
+from sympy.core.numbers import oo, equal_valued
+from sympy.core.singleton import S
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.integrals.integrals import integrate
+from sympy.printing.pretty.stringpict import stringPict
+from sympy.physics.quantum.qexpr import QExpr, dispatch_method
+
+__all__ = [
+    'KetBase',
+    'BraBase',
+    'StateBase',
+    'State',
+    'Ket',
+    'Bra',
+    'TimeDepState',
+    'TimeDepBra',
+    'TimeDepKet',
+    'OrthogonalKet',
+    'OrthogonalBra',
+    'OrthogonalState',
+    'Wavefunction'
+]
+
+
+#-----------------------------------------------------------------------------
+# States, bras and kets.
+#-----------------------------------------------------------------------------
+
+# ASCII brackets
+_lbracket = "<"
+_rbracket = ">"
+_straight_bracket = "|"
+
+
+# Unicode brackets
+# MATHEMATICAL ANGLE BRACKETS
+_lbracket_ucode = "\N{MATHEMATICAL LEFT ANGLE BRACKET}"
+_rbracket_ucode = "\N{MATHEMATICAL RIGHT ANGLE BRACKET}"
+# LIGHT VERTICAL BAR
+_straight_bracket_ucode = "\N{LIGHT VERTICAL BAR}"
+
+# Other options for unicode printing of <, > and | for Dirac notation.
+
+# LEFT-POINTING ANGLE BRACKET
+# _lbracket = "\u2329"
+# _rbracket = "\u232A"
+
+# LEFT ANGLE BRACKET
+# _lbracket = "\u3008"
+# _rbracket = "\u3009"
+
+# VERTICAL LINE
+# _straight_bracket = "\u007C"
+
+
+class StateBase(QExpr):
+    """Abstract base class for general abstract states in quantum mechanics.
+
+    All other state classes defined will need to inherit from this class. It
+    carries the basic structure for all other states such as dual, _eval_adjoint
+    and label.
+
+    This is an abstract base class and you should not instantiate it directly,
+    instead use State.
+    """
+
+    @classmethod
+    def _operators_to_state(self, ops, **options):
+        """ Returns the eigenstate instance for the passed operators.
+
+        This method should be overridden in subclasses. It will handle being
+        passed either an Operator instance or set of Operator instances. It
+        should return the corresponding state INSTANCE or simply raise a
+        NotImplementedError. See cartesian.py for an example.
+        """
+
+        raise NotImplementedError("Cannot map operators to states in this class. Method not implemented!")
+
+    def _state_to_operators(self, op_classes, **options):
+        """ Returns the operators which this state instance is an eigenstate
+        of.
+
+        This method should be overridden in subclasses. It will be called on
+        state instances and be passed the operator classes that we wish to make
+        into instances. The state instance will then transform the classes
+        appropriately, or raise a NotImplementedError if it cannot return
+        operator instances. See cartesian.py for examples,
+        """
+
+        raise NotImplementedError(
+            "Cannot map this state to operators. Method not implemented!")
+
+    @property
+    def operators(self):
+        """Return the operator(s) that this state is an eigenstate of"""
+        from .operatorset import state_to_operators  # import internally to avoid circular import errors
+        return state_to_operators(self)
+
+    def _enumerate_state(self, num_states, **options):
+        raise NotImplementedError("Cannot enumerate this state!")
+
+    def _represent_default_basis(self, **options):
+        return self._represent(basis=self.operators)
+
+    #-------------------------------------------------------------------------
+    # Dagger/dual
+    #-------------------------------------------------------------------------
+
+    @property
+    def dual(self):
+        """Return the dual state of this one."""
+        return self.dual_class()._new_rawargs(self.hilbert_space, *self.args)
+
+    @classmethod
+    def dual_class(self):
+        """Return the class used to construct the dual."""
+        raise NotImplementedError(
+            'dual_class must be implemented in a subclass'
+        )
+
+    def _eval_adjoint(self):
+        """Compute the dagger of this state using the dual."""
+        return self.dual
+
+    #-------------------------------------------------------------------------
+    # Printing
+    #-------------------------------------------------------------------------
+
+    def _pretty_brackets(self, height, use_unicode=True):
+        # Return pretty printed brackets for the state
+        # Ideally, this could be done by pform.parens but it does not support the angled < and >
+
+        # Setup for unicode vs ascii
+        if use_unicode:
+            lbracket, rbracket = getattr(self, 'lbracket_ucode', ""), getattr(self, 'rbracket_ucode', "")
+            slash, bslash, vert = '\N{BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT}', \
+                                  '\N{BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT}', \
+                                  '\N{BOX DRAWINGS LIGHT VERTICAL}'
+        else:
+            lbracket, rbracket = getattr(self, 'lbracket', ""), getattr(self, 'rbracket', "")
+            slash, bslash, vert = '/', '\\', '|'
+
+        # If height is 1, just return brackets
+        if height == 1:
+            return stringPict(lbracket), stringPict(rbracket)
+        # Make height even
+        height += (height % 2)
+
+        brackets = []
+        for bracket in lbracket, rbracket:
+            # Create left bracket
+            if bracket in {_lbracket, _lbracket_ucode}:
+                bracket_args = [ ' ' * (height//2 - i - 1) +
+                                 slash for i in range(height // 2)]
+                bracket_args.extend(
+                    [' ' * i + bslash for i in range(height // 2)])
+            # Create right bracket
+            elif bracket in {_rbracket, _rbracket_ucode}:
+                bracket_args = [ ' ' * i + bslash for i in range(height // 2)]
+                bracket_args.extend([ ' ' * (
+                    height//2 - i - 1) + slash for i in range(height // 2)])
+            # Create straight bracket
+            elif bracket in {_straight_bracket, _straight_bracket_ucode}:
+                bracket_args = [vert] * height
+            else:
+                raise ValueError(bracket)
+            brackets.append(
+                stringPict('\n'.join(bracket_args), baseline=height//2))
+        return brackets
+
+    def _sympystr(self, printer, *args):
+        contents = self._print_contents(printer, *args)
+        return '%s%s%s' % (getattr(self, 'lbracket', ""), contents, getattr(self, 'rbracket', ""))
+
+    def _pretty(self, printer, *args):
+        from sympy.printing.pretty.stringpict import prettyForm
+        # Get brackets
+        pform = self._print_contents_pretty(printer, *args)
+        lbracket, rbracket = self._pretty_brackets(
+            pform.height(), printer._use_unicode)
+        # Put together state
+        pform = prettyForm(*pform.left(lbracket))
+        pform = prettyForm(*pform.right(rbracket))
+        return pform
+
+    def _latex(self, printer, *args):
+        contents = self._print_contents_latex(printer, *args)
+        # The extra {} brackets are needed to get matplotlib's latex
+        # rendered to render this properly.
+        return '{%s%s%s}' % (getattr(self, 'lbracket_latex', ""), contents, getattr(self, 'rbracket_latex', ""))
+
+
+class KetBase(StateBase):
+    """Base class for Kets.
+
+    This class defines the dual property and the brackets for printing. This is
+    an abstract base class and you should not instantiate it directly, instead
+    use Ket.
+    """
+
+    lbracket = _straight_bracket
+    rbracket = _rbracket
+    lbracket_ucode = _straight_bracket_ucode
+    rbracket_ucode = _rbracket_ucode
+    lbracket_latex = r'\left|'
+    rbracket_latex = r'\right\rangle '
+
+    @classmethod
+    def default_args(self):
+        return ("psi",)
+
+    @classmethod
+    def dual_class(self):
+        return BraBase
+
+    def __mul__(self, other):
+        """KetBase*other"""
+        from sympy.physics.quantum.operator import OuterProduct
+        if isinstance(other, BraBase):
+            return OuterProduct(self, other)
+        else:
+            return Expr.__mul__(self, other)
+
+    def __rmul__(self, other):
+        """other*KetBase"""
+        from sympy.physics.quantum.innerproduct import InnerProduct
+        if isinstance(other, BraBase):
+            return InnerProduct(other, self)
+        else:
+            return Expr.__rmul__(self, other)
+
+    #-------------------------------------------------------------------------
+    # _eval_* methods
+    #-------------------------------------------------------------------------
+
+    def _eval_innerproduct(self, bra, **hints):
+        """Evaluate the inner product between this ket and a bra.
+
+        This is called to compute <bra|ket>, where the ket is ``self``.
+
+        This method will dispatch to sub-methods having the format::
+
+            ``def _eval_innerproduct_BraClass(self, **hints):``
+
+        Subclasses should define these methods (one for each BraClass) to
+        teach the ket how to take inner products with bras.
+        """
+        return dispatch_method(self, '_eval_innerproduct', bra, **hints)
+
+    def _apply_from_right_to(self, op, **options):
+        """Apply an Operator to this Ket as Operator*Ket
+
+        This method will dispatch to methods having the format::
+
+            ``def _apply_from_right_to_OperatorName(op, **options):``
+
+        Subclasses should define these methods (one for each OperatorName) to
+        teach the Ket how to implement OperatorName*Ket
+
+        Parameters
+        ==========
+
+        op : Operator
+            The Operator that is acting on the Ket as op*Ket
+        options : dict
+            A dict of key/value pairs that control how the operator is applied
+            to the Ket.
+        """
+        return dispatch_method(self, '_apply_from_right_to', op, **options)
+
+
+class BraBase(StateBase):
+    """Base class for Bras.
+
+    This class defines the dual property and the brackets for printing. This
+    is an abstract base class and you should not instantiate it directly,
+    instead use Bra.
+    """
+
+    lbracket = _lbracket
+    rbracket = _straight_bracket
+    lbracket_ucode = _lbracket_ucode
+    rbracket_ucode = _straight_bracket_ucode
+    lbracket_latex = r'\left\langle '
+    rbracket_latex = r'\right|'
+
+    @classmethod
+    def _operators_to_state(self, ops, **options):
+        state = self.dual_class()._operators_to_state(ops, **options)
+        return state.dual
+
+    def _state_to_operators(self, op_classes, **options):
+        return self.dual._state_to_operators(op_classes, **options)
+
+    def _enumerate_state(self, num_states, **options):
+        dual_states = self.dual._enumerate_state(num_states, **options)
+        return [x.dual for x in dual_states]
+
+    @classmethod
+    def default_args(self):
+        return self.dual_class().default_args()
+
+    @classmethod
+    def dual_class(self):
+        return KetBase
+
+    def __mul__(self, other):
+        """BraBase*other"""
+        from sympy.physics.quantum.innerproduct import InnerProduct
+        if isinstance(other, KetBase):
+            return InnerProduct(self, other)
+        else:
+            return Expr.__mul__(self, other)
+
+    def __rmul__(self, other):
+        """other*BraBase"""
+        from sympy.physics.quantum.operator import OuterProduct
+        if isinstance(other, KetBase):
+            return OuterProduct(other, self)
+        else:
+            return Expr.__rmul__(self, other)
+
+    def _represent(self, **options):
+        """A default represent that uses the Ket's version."""
+        from sympy.physics.quantum.dagger import Dagger
+        return Dagger(self.dual._represent(**options))
+
+
+class State(StateBase):
+    """General abstract quantum state used as a base class for Ket and Bra."""
+    pass
+
+
+class Ket(State, KetBase):
+    """A general time-independent Ket in quantum mechanics.
+
+    Inherits from State and KetBase. This class should be used as the base
+    class for all physical, time-independent Kets in a system. This class
+    and its subclasses will be the main classes that users will use for
+    expressing Kets in Dirac notation [1]_.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        ket. This will usually be its symbol or its quantum numbers. For
+        time-dependent state, this will include the time.
+
+    Examples
+    ========
+
+    Create a simple Ket and looking at its properties::
+
+        >>> from sympy.physics.quantum import Ket
+        >>> from sympy import symbols, I
+        >>> k = Ket('psi')
+        >>> k
+        |psi>
+        >>> k.hilbert_space
+        H
+        >>> k.is_commutative
+        False
+        >>> k.label
+        (psi,)
+
+    Ket's know about their associated bra::
+
+        >>> k.dual
+        <psi|
+        >>> k.dual_class()
+        <class 'sympy.physics.quantum.state.Bra'>
+
+    Take a linear combination of two kets::
+
+        >>> k0 = Ket(0)
+        >>> k1 = Ket(1)
+        >>> 2*I*k0 - 4*k1
+        2*I*|0> - 4*|1>
+
+    Compound labels are passed as tuples::
+
+        >>> n, m = symbols('n,m')
+        >>> k = Ket(n,m)
+        >>> k
+        |nm>
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bra-ket_notation
+    """
+
+    @classmethod
+    def dual_class(self):
+        return Bra
+
+
+class Bra(State, BraBase):
+    """A general time-independent Bra in quantum mechanics.
+
+    Inherits from State and BraBase. A Bra is the dual of a Ket [1]_. This
+    class and its subclasses will be the main classes that users will use for
+    expressing Bras in Dirac notation.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the
+        ket. This will usually be its symbol or its quantum numbers. For
+        time-dependent state, this will include the time.
+
+    Examples
+    ========
+
+    Create a simple Bra and look at its properties::
+
+        >>> from sympy.physics.quantum import Bra
+        >>> from sympy import symbols, I
+        >>> b = Bra('psi')
+        >>> b
+        <psi|
+        >>> b.hilbert_space
+        H
+        >>> b.is_commutative
+        False
+
+    Bra's know about their dual Ket's::
+
+        >>> b.dual
+        |psi>
+        >>> b.dual_class()
+        <class 'sympy.physics.quantum.state.Ket'>
+
+    Like Kets, Bras can have compound labels and be manipulated in a similar
+    manner::
+
+        >>> n, m = symbols('n,m')
+        >>> b = Bra(n,m) - I*Bra(m,n)
+        >>> b
+        -I*<mn| + <nm|
+
+    Symbols in a Bra can be substituted using ``.subs``::
+
+        >>> b.subs(n,m)
+        <mm| - I*<mm|
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bra-ket_notation
+    """
+
+    @classmethod
+    def dual_class(self):
+        return Ket
+
+#-----------------------------------------------------------------------------
+# Time dependent states, bras and kets.
+#-----------------------------------------------------------------------------
+
+
+class TimeDepState(StateBase):
+    """Base class for a general time-dependent quantum state.
+
+    This class is used as a base class for any time-dependent state. The main
+    difference between this class and the time-independent state is that this
+    class takes a second argument that is the time in addition to the usual
+    label argument.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the ket. This
+        will usually be its symbol or its quantum numbers. For time-dependent
+        state, this will include the time as the final argument.
+    """
+
+    #-------------------------------------------------------------------------
+    # Initialization
+    #-------------------------------------------------------------------------
+
+    @classmethod
+    def default_args(self):
+        return ("psi", "t")
+
+    #-------------------------------------------------------------------------
+    # Properties
+    #-------------------------------------------------------------------------
+
+    @property
+    def label(self):
+        """The label of the state."""
+        return self.args[:-1]
+
+    @property
+    def time(self):
+        """The time of the state."""
+        return self.args[-1]
+
+    #-------------------------------------------------------------------------
+    # Printing
+    #-------------------------------------------------------------------------
+
+    def _print_time(self, printer, *args):
+        return printer._print(self.time, *args)
+
+    _print_time_repr = _print_time
+    _print_time_latex = _print_time
+
+    def _print_time_pretty(self, printer, *args):
+        pform = printer._print(self.time, *args)
+        return pform
+
+    def _print_contents(self, printer, *args):
+        label = self._print_label(printer, *args)
+        time = self._print_time(printer, *args)
+        return '%s;%s' % (label, time)
+
+    def _print_label_repr(self, printer, *args):
+        label = self._print_sequence(self.label, ',', printer, *args)
+        time = self._print_time_repr(printer, *args)
+        return '%s,%s' % (label, time)
+
+    def _print_contents_pretty(self, printer, *args):
+        label = self._print_label_pretty(printer, *args)
+        time = self._print_time_pretty(printer, *args)
+        return printer._print_seq((label, time), delimiter=';')
+
+    def _print_contents_latex(self, printer, *args):
+        label = self._print_sequence(
+            self.label, self._label_separator, printer, *args)
+        time = self._print_time_latex(printer, *args)
+        return '%s;%s' % (label, time)
+
+
+class TimeDepKet(TimeDepState, KetBase):
+    """General time-dependent Ket in quantum mechanics.
+
+    This inherits from ``TimeDepState`` and ``KetBase`` and is the main class
+    that should be used for Kets that vary with time. Its dual is a
+    ``TimeDepBra``.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the ket. This
+        will usually be its symbol or its quantum numbers. For time-dependent
+        state, this will include the time as the final argument.
+
+    Examples
+    ========
+
+    Create a TimeDepKet and look at its attributes::
+
+        >>> from sympy.physics.quantum import TimeDepKet
+        >>> k = TimeDepKet('psi', 't')
+        >>> k
+        |psi;t>
+        >>> k.time
+        t
+        >>> k.label
+        (psi,)
+        >>> k.hilbert_space
+        H
+
+    TimeDepKets know about their dual bra::
+
+        >>> k.dual
+        <psi;t|
+        >>> k.dual_class()
+        <class 'sympy.physics.quantum.state.TimeDepBra'>
+    """
+
+    @classmethod
+    def dual_class(self):
+        return TimeDepBra
+
+
+class TimeDepBra(TimeDepState, BraBase):
+    """General time-dependent Bra in quantum mechanics.
+
+    This inherits from TimeDepState and BraBase and is the main class that
+    should be used for Bras that vary with time. Its dual is a TimeDepBra.
+
+    Parameters
+    ==========
+
+    args : tuple
+        The list of numbers or parameters that uniquely specify the ket. This
+        will usually be its symbol or its quantum numbers. For time-dependent
+        state, this will include the time as the final argument.
+
+    Examples
+    ========
+
+        >>> from sympy.physics.quantum import TimeDepBra
+        >>> b = TimeDepBra('psi', 't')
+        >>> b
+        <psi;t|
+        >>> b.time
+        t
+        >>> b.label
+        (psi,)
+        >>> b.hilbert_space
+        H
+        >>> b.dual
+        |psi;t>
+    """
+
+    @classmethod
+    def dual_class(self):
+        return TimeDepKet
+
+
+class OrthogonalState(State, StateBase):
+    """General abstract quantum state used as a base class for Ket and Bra."""
+    pass
+
+class OrthogonalKet(OrthogonalState, KetBase):
+    """Orthogonal Ket in quantum mechanics.
+
+    The inner product of two states with different labels will give zero,
+    states with the same label will give one.
+
+        >>> from sympy.physics.quantum import OrthogonalBra, OrthogonalKet
+        >>> from sympy.abc import m, n
+        >>> (OrthogonalBra(n)*OrthogonalKet(n)).doit()
+        1
+        >>> (OrthogonalBra(n)*OrthogonalKet(n+1)).doit()
+        0
+        >>> (OrthogonalBra(n)*OrthogonalKet(m)).doit()
+        <n|m>
+    """
+
+    @classmethod
+    def dual_class(self):
+        return OrthogonalBra
+
+    def _eval_innerproduct(self, bra, **hints):
+
+        if len(self.args) != len(bra.args):
+            raise ValueError('Cannot multiply a ket that has a different number of labels.')
+
+        for arg, bra_arg in zip(self.args, bra.args):
+            diff = arg - bra_arg
+            diff = diff.expand()
+
+            is_zero = diff.is_zero
+
+            if is_zero is False:
+                return S.Zero # i.e. Integer(0)
+
+            if is_zero is None:
+                return None
+
+        return S.One # i.e. Integer(1)
+
+
+class OrthogonalBra(OrthogonalState, BraBase):
+    """Orthogonal Bra in quantum mechanics.
+    """
+
+    @classmethod
+    def dual_class(self):
+        return OrthogonalKet
+
+
+class Wavefunction(Function):
+    """Class for representations in continuous bases
+
+    This class takes an expression and coordinates in its constructor. It can
+    be used to easily calculate normalizations and probabilities.
+
+    Parameters
+    ==========
+
+    expr : Expr
+           The expression representing the functional form of the w.f.
+
+    coords : Symbol or tuple
+           The coordinates to be integrated over, and their bounds
+
+    Examples
+    ========
+
+    Particle in a box, specifying bounds in the more primitive way of using
+    Piecewise:
+
+        >>> from sympy import Symbol, Piecewise, pi, N
+        >>> from sympy.functions import sqrt, sin
+        >>> from sympy.physics.quantum.state import Wavefunction
+        >>> x = Symbol('x', real=True)
+        >>> n = 1
+        >>> L = 1
+        >>> g = Piecewise((0, x < 0), (0, x > L), (sqrt(2//L)*sin(n*pi*x/L), True))
+        >>> f = Wavefunction(g, x)
+        >>> f.norm
+        1
+        >>> f.is_normalized
+        True
+        >>> p = f.prob()
+        >>> p(0)
+        0
+        >>> p(L)
+        0
+        >>> p(0.5)
+        2
+        >>> p(0.85*L)
+        2*sin(0.85*pi)**2
+        >>> N(p(0.85*L))
+        0.412214747707527
+
+    Additionally, you can specify the bounds of the function and the indices in
+    a more compact way:
+
+        >>> from sympy import symbols, pi, diff
+        >>> from sympy.functions import sqrt, sin
+        >>> from sympy.physics.quantum.state import Wavefunction
+        >>> x, L = symbols('x,L', positive=True)
+        >>> n = symbols('n', integer=True, positive=True)
+        >>> g = sqrt(2/L)*sin(n*pi*x/L)
+        >>> f = Wavefunction(g, (x, 0, L))
+        >>> f.norm
+        1
+        >>> f(L+1)
+        0
+        >>> f(L-1)
+        sqrt(2)*sin(pi*n*(L - 1)/L)/sqrt(L)
+        >>> f(-1)
+        0
+        >>> f(0.85)
+        sqrt(2)*sin(0.85*pi*n/L)/sqrt(L)
+        >>> f(0.85, n=1, L=1)
+        sqrt(2)*sin(0.85*pi)
+        >>> f.is_commutative
+        False
+
+    All arguments are automatically sympified, so you can define the variables
+    as strings rather than symbols:
+
+        >>> expr = x**2
+        >>> f = Wavefunction(expr, 'x')
+        >>> type(f.variables[0])
+        <class 'sympy.core.symbol.Symbol'>
+
+    Derivatives of Wavefunctions will return Wavefunctions:
+
+        >>> diff(f, x)
+        Wavefunction(2*x, x)
+
+    """
+
+    #Any passed tuples for coordinates and their bounds need to be
+    #converted to Tuples before Function's constructor is called, to
+    #avoid errors from calling is_Float in the constructor
+    def __new__(cls, *args, **options):
+        new_args = [None for i in args]
+        ct = 0
+        for arg in args:
+            if isinstance(arg, tuple):
+                new_args[ct] = Tuple(*arg)
+            else:
+                new_args[ct] = arg
+            ct += 1
+
+        return super().__new__(cls, *new_args, **options)
+
+    def __call__(self, *args, **options):
+        var = self.variables
+
+        if len(args) != len(var):
+            raise NotImplementedError(
+                "Incorrect number of arguments to function!")
+
+        ct = 0
+        #If the passed value is outside the specified bounds, return 0
+        for v in var:
+            lower, upper = self.limits[v]
+
+            #Do the comparison to limits only if the passed symbol is actually
+            #a symbol present in the limits;
+            #Had problems with a comparison of x > L
+            if isinstance(args[ct], Expr) and \
+                not (lower in args[ct].free_symbols
+                     or upper in args[ct].free_symbols):
+                continue
+
+            if (args[ct] < lower) == True or (args[ct] > upper) == True:
+                return S.Zero
+
+            ct += 1
+
+        expr = self.expr
+
+        #Allows user to make a call like f(2, 4, m=1, n=1)
+        for symbol in list(expr.free_symbols):
+            if str(symbol) in options.keys():
+                val = options[str(symbol)]
+                expr = expr.subs(symbol, val)
+
+        return expr.subs(zip(var, args))
+
+    def _eval_derivative(self, symbol):
+        expr = self.expr
+        deriv = expr._eval_derivative(symbol)
+
+        return Wavefunction(deriv, *self.args[1:])
+
+    def _eval_conjugate(self):
+        return Wavefunction(conjugate(self.expr), *self.args[1:])
+
+    def _eval_transpose(self):
+        return self
+
+    @property
+    def free_symbols(self):
+        return self.expr.free_symbols
+
+    @property
+    def is_commutative(self):
+        """
+        Override Function's is_commutative so that order is preserved in
+        represented expressions
+        """
+        return False
+
+    @classmethod
+    def eval(self, *args):
+        return None
+
+    @property
+    def variables(self):
+        """
+        Return the coordinates which the wavefunction depends on
+
+        Examples
+        ========
+
+            >>> from sympy.physics.quantum.state import Wavefunction
+            >>> from sympy import symbols
+            >>> x,y = symbols('x,y')
+            >>> f = Wavefunction(x*y, x, y)
+            >>> f.variables
+            (x, y)
+            >>> g = Wavefunction(x*y, x)
+            >>> g.variables
+            (x,)
+
+        """
+        var = [g[0] if isinstance(g, Tuple) else g for g in self._args[1:]]
+        return tuple(var)
+
+    @property
+    def limits(self):
+        """
+        Return the limits of the coordinates which the w.f. depends on If no
+        limits are specified, defaults to ``(-oo, oo)``.
+
+        Examples
+        ========
+
+            >>> from sympy.physics.quantum.state import Wavefunction
+            >>> from sympy import symbols
+            >>> x, y = symbols('x, y')
+            >>> f = Wavefunction(x**2, (x, 0, 1))
+            >>> f.limits
+            {x: (0, 1)}
+            >>> f = Wavefunction(x**2, x)
+            >>> f.limits
+            {x: (-oo, oo)}
+            >>> f = Wavefunction(x**2 + y**2, x, (y, -1, 2))
+            >>> f.limits
+            {x: (-oo, oo), y: (-1, 2)}
+
+        """
+        limits = [(g[1], g[2]) if isinstance(g, Tuple) else (-oo, oo)
+                  for g in self._args[1:]]
+        return dict(zip(self.variables, tuple(limits)))
+
+    @property
+    def expr(self):
+        """
+        Return the expression which is the functional form of the Wavefunction
+
+        Examples
+        ========
+
+            >>> from sympy.physics.quantum.state import Wavefunction
+            >>> from sympy import symbols
+            >>> x, y = symbols('x, y')
+            >>> f = Wavefunction(x**2, x)
+            >>> f.expr
+            x**2
+
+        """
+        return self._args[0]
+
+    @property
+    def is_normalized(self):
+        """
+        Returns true if the Wavefunction is properly normalized
+
+        Examples
+        ========
+
+            >>> from sympy import symbols, pi
+            >>> from sympy.functions import sqrt, sin
+            >>> from sympy.physics.quantum.state import Wavefunction
+            >>> x, L = symbols('x,L', positive=True)
+            >>> n = symbols('n', integer=True, positive=True)
+            >>> g = sqrt(2/L)*sin(n*pi*x/L)
+            >>> f = Wavefunction(g, (x, 0, L))
+            >>> f.is_normalized
+            True
+
+        """
+
+        return equal_valued(self.norm, 1)
+
+    @property  # type: ignore
+    @cacheit
+    def norm(self):
+        """
+        Return the normalization of the specified functional form.
+
+        This function integrates over the coordinates of the Wavefunction, with
+        the bounds specified.
+
+        Examples
+        ========
+
+            >>> from sympy import symbols, pi
+            >>> from sympy.functions import sqrt, sin
+            >>> from sympy.physics.quantum.state import Wavefunction
+            >>> x, L = symbols('x,L', positive=True)
+            >>> n = symbols('n', integer=True, positive=True)
+            >>> g = sqrt(2/L)*sin(n*pi*x/L)
+            >>> f = Wavefunction(g, (x, 0, L))
+            >>> f.norm
+            1
+            >>> g = sin(n*pi*x/L)
+            >>> f = Wavefunction(g, (x, 0, L))
+            >>> f.norm
+            sqrt(2)*sqrt(L)/2
+
+        """
+
+        exp = self.expr*conjugate(self.expr)
+        var = self.variables
+        limits = self.limits
+
+        for v in var:
+            curr_limits = limits[v]
+            exp = integrate(exp, (v, curr_limits[0], curr_limits[1]))
+
+        return sqrt(exp)
+
+    def normalize(self):
+        """
+        Return a normalized version of the Wavefunction
+
+        Examples
+        ========
+
+            >>> from sympy import symbols, pi
+            >>> from sympy.functions import sin
+            >>> from sympy.physics.quantum.state import Wavefunction
+            >>> x = symbols('x', real=True)
+            >>> L = symbols('L', positive=True)
+            >>> n = symbols('n', integer=True, positive=True)
+            >>> g = sin(n*pi*x/L)
+            >>> f = Wavefunction(g, (x, 0, L))
+            >>> f.normalize()
+            Wavefunction(sqrt(2)*sin(pi*n*x/L)/sqrt(L), (x, 0, L))
+
+        """
+        const = self.norm
+
+        if const is oo:
+            raise NotImplementedError("The function is not normalizable!")
+        else:
+            return Wavefunction((const)**(-1)*self.expr, *self.args[1:])
+
+    def prob(self):
+        r"""
+        Return the absolute magnitude of the w.f., `|\psi(x)|^2`
+
+        Examples
+        ========
+
+            >>> from sympy import symbols, pi
+            >>> from sympy.functions import sin
+            >>> from sympy.physics.quantum.state import Wavefunction
+            >>> x, L = symbols('x,L', real=True)
+            >>> n = symbols('n', integer=True)
+            >>> g = sin(n*pi*x/L)
+            >>> f = Wavefunction(g, (x, 0, L))
+            >>> f.prob()
+            Wavefunction(sin(pi*n*x/L)**2, x)
+
+        """
+
+        return Wavefunction(self.expr*conjugate(self.expr), *self.variables)

venv/lib/python3.10/site-packages/sympy/physics/tests/test_clebsch_gordan.py

@@ -0,0 +1,191 @@
+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
+    alpha, beta, gamma = symbols("alpha, beta, gamma", real=True)
+    d = wigner_d_small(half, beta).subs({beta: pi/2})
+    d_ = Matrix([[1, 1], [-1, 1]])/sqrt(2)
+    assert d == d_
+
+    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)

venv/lib/python3.10/site-packages/sympy/physics/tests/test_hydrogen.py

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

venv/lib/python3.10/site-packages/sympy/physics/tests/test_paulialgebra.py

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

venv/lib/python3.10/site-packages/sympy/physics/tests/test_physics_matrices.py

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