o jgBy@sdZddlmZddlmZddlmZddlmZddl m Z m Z ddl m Z ddlmZdd lmZdd lmZdd lmZdd lmZmZgd ZdZdZdZdZdZdZGdddeZ Gddde Z!Gddde Z"Gddde Z#Gddde#e!Z$Gddde#e"Z%Gd d!d!e Z&Gd"d#d#e&e!Z'Gd$d%d%e&e"Z(Gd&d'd'e#e Z)Gd(d)d)e)e!Z*Gd*d+d+e)e"Z+Gd,d-d-eZ,d.S)/zDirac notation for states.)cacheit)Tuple)Expr)Function)oo equal_valued)S) conjugate)sqrt) integrate) stringPict)QExprdispatch_method) KetBaseBraBase StateBaseStateKetBra TimeDepState TimeDepBra TimeDepKet OrthogonalKet OrthogonalBraOrthogonalState Wavefunction<>|u⟨u⟩u❘c@seZdZdZeddZddZeddZdd Z d d Z d d Z eddZ eddZ ddZdddZddZddZddZdS)ra_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. cKtd)ad 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. zECannot map operators to states in this class. Method not implemented!NotImplementedError)selfopsoptionsr%S/var/www/html/zoom/venv/lib/python3.10/site-packages/sympy/physics/quantum/state.py_operators_to_stateJs zStateBase._operators_to_statecKr)a 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, z;Cannot map this state to operators. Method not implemented!r r" op_classesr$r%r%r&_state_to_operatorsVs zStateBase._state_to_operatorscCsddlm}||S)z:Return the operator(s) that this state is an eigenstate of)state_to_operators) operatorsetr,)r"r,r%r%r& operatorsds zStateBase.operatorscKr)NzCannot enumerate this state!r )r" num_statesr$r%r%r&_enumerate_statejszStateBase._enumerate_statecKs|j|jdS)N)basis) _representr.)r"r$r%r%r&_represent_default_basismsz"StateBase._represent_default_basiscKdSNr%r"opr$r%r%r&_apply_operatorpzStateBase._apply_operatorcCs|j|jg|jRS)z"Return the dual state of this one.) dual_class _new_rawargs hilbert_spaceargsr"r%r%r&dualwszStateBase.dualcCr)z,Return the class used to construct the dual.z,dual_class must be implemented in a subclassr r>r%r%r&r:|szStateBase.dual_classcCs|jS)z0Compute the dagger of this state using the dual.r?r>r%r%r& _eval_adjointszStateBase._eval_adjointTc sX|rt|ddt|dd}}d\}nt|ddt|dd}}d\}dkr3t|t|fSd 7g}||fD]j}|tthvrffd d td D}|fd d td Dn5|tthvrfd d td D}|fdd td Dn|tt hvr|g}nt || td |d dq?|S)Nlbracket_ucoderbracket_ucode)u╱u╲u│lbracketrbracket)/\rr+c$g|]}dd|dqS rIr+r%.0iheightslashr%r& s z.StateBase._pretty_brackets..cg|]}d|qSrLr%rMbslashr%r&rScrTrUr%rMrVr%r&rSrXcrJrKr%rMrPr%r&rSs )baseline) getattrr _lbracket_lbracket_ucoderangeextend _rbracket_rbracket_ucode_straight_bracket_straight_bracket_ucode ValueErrorappendjoin) r"rQ use_unicoderErFvertbracketsbracket bracket_argsr%)rWrQrRr&_pretty_bracketss:           zStateBase._pretty_bracketscG0|j|g|R}dt|dd|t|ddfS)Nz%s%s%srErCrF)_print_contentsr[r"printerr=contentsr%r%r& _sympystrszStateBase._sympystrcGsTddlm}|j|g|R}|||j\}}|||}|||}|S)Nr) prettyForm) sympy.printing.pretty.stringpictrs_print_contents_prettyrlrQ _use_unicodeleftright)r"rpr=rspformrErFr%r%r&_prettys  zStateBase._prettycGrm)Nz{%s%s%s}lbracket_latexrCrbracket_latex)_print_contents_latexr[ror%r%r&_latexszStateBase._latexN)T)__name__ __module__ __qualname____doc__ classmethodr'r*propertyr.r0r3r8r?r:rArlrrrzr~r%r%r%r&r?s&      * rc@s`eZdZdZeZeZeZ e Z dZ dZ eddZeddZdd Zd d Zd d ZddZdS)rzBase 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. z\left|z\right\rangle cCdS)N)psir%r>r%r%r& default_argszKetBase.default_argscCtSr5)rr>r%r%r&r:rzKetBase.dual_classcC,ddlm}t|tr|||St||S)z KetBase*otherr OuterProduct)sympy.physics.quantum.operatorr isinstancerr__mul__r"otherrr%r%r&r    zKetBase.__mul__cC,ddlm}t|tr|||St||S)z other*KetBaser InnerProduct)"sympy.physics.quantum.innerproductrrrr__rmul__r"rrr%r%r&rrzKetBase.__rmul__cKt|d|fi|S)aEvaluate the inner product between this ket and a bra. This is called to compute , 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. _eval_innerproductr)r"brahintsr%r%r&rs zKetBase._eval_innerproductcKr)a?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. _apply_from_right_torr6r%r%r&rszKetBase._apply_from_right_toN)rrrrrbrEr`rFrcrBrarDr{r|rrr:rrrrr%r%r%r&rs    rc@steZdZdZeZeZeZ e Z dZ dZ eddZddZdd Zed d Zed d ZddZddZddZdS)rzBase 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. z \left\langle z\right|cKs|j|fi|}|jSr5)r:r'r?)r"r#r$stater%r%r&r')szBraBase._operators_to_statecKs|jj|fi|Sr5)r?r*r(r%r%r&r*.zBraBase._state_to_operatorscKs"|jj|fi|}dd|DS)NcSsg|]}|jqSr%r@)rNxr%r%r&rS3sz,BraBase._enumerate_state..)r?r0)r"r/r$ dual_statesr%r%r&r01szBraBase._enumerate_statecCs |Sr5)r:rr>r%r%r&r5s zBraBase.default_argscCrr5)rr>r%r%r&r:9rzBraBase.dual_classcCr)z BraBase*otherrr)rrrrrrrr%r%r&r=rzBraBase.__mul__cCr)z other*BraBaserr)rrrrrrrr%r%r&rErzBraBase.__rmul__cKs"ddlm}||jjdi|S)z0A default represent that uses the Ket's version.r)DaggerNr%)sympy.physics.quantum.daggerrr?r2)r"r$rr%r%r&r2Ms zBraBase._representN)rrrrr\rErbrFr]rBrcrDr{r|rr'r*r0rr:rrr2r%r%r%r&rs&    rc@eZdZdZdS)rDGeneral abstract quantum state used as a base class for Ket and Bra.Nrrrrr%r%r%r&rSrc@eZdZdZeddZdS)raA 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 >> k.dual_class() 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 cCrr5)rr>r%r%r&r:rzKet.dual_classNrrrrrr:r%r%r%r&rXs;rc@r)raLA 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 >> b.hilbert_space H >>> b.is_commutative False Bra's know about their dual Ket's:: >>> b.dual |psi> >>> b.dual_class() 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*>> b.subs(n,m) r%r%r&r:rzBra.dual_classNrr%r%r%r&rs7rc@sleZdZdZeddZeddZeddZdd Z e Z e Z d d Z d d Z ddZddZddZdS)raFBase 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. cCr)N)rtr%r>r%r%r&rrzTimeDepState.default_argscCs|jddS)zThe label of the state.Nr=r>r%r%r&labelszTimeDepState.labelcC |jdS)zThe time of the state.rrr>r%r%r&times zTimeDepState.timecGs|j|jg|RSr5_printr)r"rpr=r%r%r& _print_timerzTimeDepState._print_timecGs|j|jg|R}|Sr5r)r"rpr=ryr%r%r&_print_time_pretty szTimeDepState._print_time_prettycGs0|j|g|R}|j|g|R}d||fSNz%s;%s) _print_labelrr"rpr=rrr%r%r&rns zTimeDepState._print_contentscGs6|j|jd|g|R}|j|g|R}d||fS)N,z%s,%s)_print_sequencer_print_time_reprrr%r%r&_print_label_reprs zTimeDepState._print_label_reprcGs6|j|g|R}|j|g|R}|j||fddS)N;) delimiter)_print_label_prettyr _print_seqrr%r%r&rusz#TimeDepState._print_contents_prettycGs8|j|j|j|g|R}|j|g|R}d||fSr)rr_label_separator_print_time_latexrr%r%r&r}s  z"TimeDepState._print_contents_latexN)rrrrrrrrrrrrrrnrrur}r%r%r%r&rs     rc@r)raGeneral 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 >> k.dual_class() cCrr5)rr>r%r%r&r:LrzTimeDepKet.dual_classNrr%r%r%r&r%s&rc@r)raGeneral 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 >> b.time t >>> b.label (psi,) >>> b.hilbert_space H >>> b.dual |psi;t> cCrr5)rr>r%r%r&r:przTimeDepBra.dual_classNrr%r%r%r&rQsrc@r)rrNrr%r%r%r&rurrc@s$eZdZdZeddZddZdS)raOrthogonal 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() cCrr5)rr>r%r%r&r:rzOrthogonalKet.dual_classcKspt|jt|jkrtdt|j|jD]\}}||}|}|j}|dur-tjS|dur4dSqtjS)Nzr%r%r&r:rzOrthogonalBra.dual_classNrr%r%r%r&rsrcseZdZdZfddZddZddZdd Zd d Ze d d Z e ddZ e ddZ e ddZe ddZe ddZe ddZe eddZddZddZZS) ra 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]) Derivatives of Wavefunctions will return Wavefunctions: >>> diff(f, x) Wavefunction(2*x, x) cs^dd|D}d}|D]}t|trt|||<n|||<|d7}q tj|g|Ri|S)NcSsg|]}dqSr5r%rMr%r%r&rSsz(Wavefunction.__new__..rr+)rtuplersuper__new__)clsr=r$new_argsctr __class__r%r&rs  zWavefunction.__new__c Os|j}t|t|krtdd}|D]8}|j|\}}t||tr2|||jvs2|||jvs2q|||kdksB|||kdkrGtjS|d7}q|j }t |jD]} t | | vrj|t | } | | | }qT| t||S)Nz*Incorrect number of arguments to function!rTr+) variablesrr!limitsrr free_symbolsrrexprliststrkeyssubsr) r"r=r$varrvlowerupperrsymbolvalr%r%r&__call__s,     zWavefunction.__call__cCs*|j}||}t|g|jddRSNr+)r_eval_derivativerr=)r"rrderivr%r%r&r1s zWavefunction._eval_derivativecCs tt|jg|jddRSr)rr rr=r>r%r%r&_eval_conjugate7s zWavefunction._eval_conjugatecCs|Sr5r%r>r%r%r&_eval_transpose:r9zWavefunction._eval_transposecCs|jjSr5)rrr>r%r%r&r=szWavefunction.free_symbolscCr)zr Override Function's is_commutative so that order is preserved in represented expressions Fr%r>r%r%r&is_commutativeAszWavefunction.is_commutativecGr4r5r%)r"r=r%r%r&evalIrzWavefunction.evalcCs dd|jddD}t|S)a 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,) cSs"g|] }t|tr |dn|qS)r)rrrNgr%r%r&rS`s"z*Wavefunction.variables..r+N)_argsr)r"rr%r%r&rMszWavefunction.variablescCs,dd|jddD}tt|jt|S)a 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)} cSs0g|]}t|tr|d|dfnt tfqS)r+rI)rrrrr%r%r&rSzs(z'Wavefunction.limits..r+N)rdictrrr)r"rr%r%r&rcs zWavefunction.limitscCr)ae 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 r)rr>r%r%r&r~s zWavefunction.exprcCs t|jdS)a 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 r+)rnormr>r%r%r& is_normalizeds zWavefunction.is_normalizedcCsN|jt|j}|j}|j}|D]}||}t|||d|df}qt|S)a 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 rr+)rr rrr r )r"exprrr curr_limitsr%r%r&rszWavefunction.normcCs:|j}|tur tdt|d|jg|jddRS)aU 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)) z!The function is not normalizable!rr+N)rrr!rrr=)r"constr%r%r& normalizes$zWavefunction.normalizecCst|jt|jg|jRS)a  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) )rrr rr>r%r%r&probszWavefunction.prob)rrrrrrrrrrrrrrrrrrrrrr __classcell__r%r%rr&rs4 W #        $rN)-rsympy.core.cachersympy.core.containersrsympy.core.exprrsympy.core.functionrsympy.core.numbersrrsympy.core.singletonr$sympy.functions.elementary.complexesr (sympy.functions.elementary.miscellaneousr sympy.integrals.integralsr rtr sympy.physics.quantum.qexprr r__all__r\r`rbr]rarcrrrrrrrrrrrrrr%r%r%r&sB          O9AAK,$(