+
    i[%                     T   R t ^ RIHtHtHtHtHtHtHt ^ RI	H
t
 ^ RIHtHtHt ^ RIHtHtHtHtHtHtHt RR.t]]! ]]34      ]]! ]]34      ]]! ]]34      ]]
]]! ]]]34      ]]]]/t]P5                  4        U Uu/ uF  w  rWbK	  	  upp tR tR tR	 tR
 tR t R t!R# u upp i )a  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
)XOpYOpZOpXKetPxOpPxKetPositionKet3D)Operator)	StateBaseBraBaseKet)JxOpJyOpJzOpJ2OpJxKetJyKetJzKetoperators_to_statestate_to_operatorsc                   \        V \        \        34      '       g"   \        V \        4      '       g   \	        R4      h\        V \        4      '       d   V  F<  p\        V\        4      '       d   K  \        V\        4      '       d   K3  \	        R4      h	  \        V 4      pV\        9   d:    V Uu. uF	  qD! 4       NK  	  pp\        \        V,          \        V4      3/ VB pV# V Uu. uF  p\        V4      NK  	  pp\        V4      p	V	\        9   d   \        \        V	,          V3/ VB pV# RpV# V \        9   d#    V ! 4       p
\        \        V ,          V
3/ VB pV# \        V 4      \        9   d"   \        \        \        V 4      ,          V 3/ VB # R# u upi   \         d    \        T,          p T# i ; iu upi   \         d    \        T ,          p T# i ; i)a  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>
z%Argument is not an Operator or a set!zSet is not all Operators!N)	
isinstancer	   set
issubclassNotImplementedError	frozenset
op_mapping
_get_statetype)	operatorsoptionssopsopop_instancesretotmpclassesop_instances   &,         _/var/www/html/photoedit/myenv/lib/python3.14/site-packages/sympy/physics/quantum/operatorset.pyr   r   /   s   l y8S/22jH6U6U!"IJJ)S!!Aq(++ H--)*EFF 
 	"*&/23ss3 C#l2COwO J$'(Cq47CC(nG*$ G!4cEWE J J
",'k I!6OwO J)_
*ji99PPP9  4& & oJ&
 ) ' , +J,s<   -F 1F #F )F;?G  F F87F8 GGc           	        \        V \        4      '       g"   \        V \        4      '       g   \        R4      hV \        9   d0   \        V 4      p \        V\        \        V ,          4      3/ VB pEM	\        V 4      \        9   d,   \        V \        \        \        V 4      ,          4      3/ VB pM\        V \        4      '       dI   V P                  4       \        9   d0   \        V \        \        V P                  4       ,          4      4      pMl\        V \        4      '       dU   V P                  4       \        9   d<   \        V 4      p \        V\        \        V P                  4       ,          4      4      pMRp\        V4      #   \        \        3 d    \        T ,          p L+i ; i  \        \        3 d    \        T P                  4       ,          p L]i ; i)a  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
zArgument is not a state!N)r   r
   r   r   state_mapping_make_default_get_ops	_make_set	TypeErrorr   r   
dual_class)stater    
state_instr%   s   &,  r*   r   r      s   v ui((Jui,H,H!"<=="5)
	':$]5%9:G>EGC 
e	%u tE{!;<I@GI	E7	#	#(8(8(:m(Ku u/?/?/A!BCE	E7	#	#(8(8(:m(K"5)
	4:$]53C3C3E%FGIC
 S>% $Y/ 	'&C	' $Y/ 	4 0 0 23C	4s$   !F 
.F* F'&F'*,GGc                 >     V ! 4       pV#   \          d    T p T# i ; iN)r0   )exprr%   s   & r*   r-   r-      s0    f J  Js    c                 h     V P                   ! V3/ VB pV#   \         d    \        T 4      p T# i ; ir5   )_operators_to_stater   r-   )state_classr"   r    r%   s   &&, r*   r   r      sC    )--c=W= J  )K(J)s    11c                 b    V P                   ! V3/ VB p\        T\        4      '       d   \        T4      ^8X  d
   T^ ,          # T#   \         d^    \        T\        \        \
        34      '       d/   \        ;QJ d    . R  T 4       F  NK  	  5M! R  T 4       4      p L\        T4      p Li ; i)c              3   8   "   T F  p\        V4      x  K  	  R # 5ir5   )r-   ).0xs   & r*   	<genexpr>_get_ops.<locals>.<genexpr>	  s     =*Qa((*s   )_state_to_operatorsr   r   r   tupler   r-   len)r3   
op_classesr    r%   s   &&, r*   r.   r.     s    ,,,ZC7C #sCA1vJ  ,j3y"9::%=*=%%=*==C
+C	,s   A 6B.=!B. B.-B.c                 ^    \        V \        \        \        34      '       d   \	        V 4      # V # r5   )r   rA   listr   r   )r"   s   &r*   r/   r/     s$    #tY/003x
    N)"__doc__sympy.physics.quantum.cartesianr   r   r   r   r   r   r   sympy.physics.quantum.operatorr	   sympy.physics.quantum.stater
   r   r   sympy.physics.quantum.spinr   r   r   r   r   r   r   __all__r   r,   itemsr   r   r   r-   r   r.   r/   )kvs   00r*   <module>rP      s    < < < 3 ? ?/ / /  D$<0D$<0D$<0xCc?!;  -22454tqad45
aHUp	"O 6s   ?B$