
    sg[%                     R   d Z ddlmZmZmZmZmZmZmZ ddl	m
Z
 ddlmZmZmZ ddlmZmZmZmZmZmZmZ ddgZe eeef      e eeef      e eeef      ee
e eeeef      eeeeiZej5                         D  ci c]  \  } }|| 
 c}} Zd Zd	 Zd
 Zd Zd Z d Z!yc c}} w )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                 $   t        | t        t        f      st        | t              st	        d      t        | t              r| D ].  }t        |t              rt        |t              r%t	        d       t        |       }|t        v r4	 |D cg c]	  } |        }}t        t        |   t        |      fi |}|S |D cg c]  }t        |       }}t        |      }	|	t        v rt        t        |	   |fi |}|S d}|S | t        v r	  |        }
t        t        |    |
fi |}|S t        |       t        v rt        t        t        |          | fi |S yc c}w # t        $ r t        |   }Y |S w xY wc c}w # t        $ r t        |    }Y |S w xY w)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              T/var/www/html/venv/lib/python3.12/site-packages/sympy/physics/quantum/operatorset.pyr   r   /   s   l y8S/2jH6U!"IJJ)S! 	GAq(+ H-)*EFF	G
 	"*&/2333 C#l2COwO J$'(q47(C(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<   	E EE  E4
E9 E E10E19FFc           	         t        | t              st        | t              st        d      | t        v r4t        |       }	 t        |t        t        |          fi |}t        |      S t        |       t        v r1t        | t        t        t        |                fi |}t        |      S t        | t              rK| j                         t        v r5t        | t        t        | j                                        }t        |      S t        | t              rW| j                         t        v rAt        |       }	 t        |t        t        | j                                        }t        |      S d}t        |      S # t        t        f$ r t        |    }Y t        |      S w xY w# t        t        f$ r$ t        | j                            }Y t        |      S w xY w)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!"<=="5)
	':$]5%9:G>EGC( S>! 
e	%u tE{!;<I@GI S> 
E7	#(8(8(:m(Ku u/?/?/A!BCE S> 
E7	#(8(8(:m(K"5)
	4:$]53C3C3E%FGIC S> S>% $Y/ 	'&C" S>%	' $Y/ 	4 0 0 23C S>	4s$    E9 7*F! 9FF!&GGc                 :    	  |        }|S # t         $ r | }Y |S w xY wN)r1   )exprr&   s     r+   r.   r.      s0    f J  Js    c                 d    	  | j                   |fi |}|S # t        $ r t        |       }Y |S w xY wr6   )_operators_to_stater   r.   )state_classr#   r!   r&   s       r+   r   r      sE    )-k--c=W= J  )K(J)s    //c                    	  | j                   |fi |}t        |t              rt        |      dk(  r|d   S |S # t        $ r< t        |t        t        t
        f      rt	        d |D              }nt        |      }Y iw xY w)Nc              3   2   K   | ]  }t        |        y wr6   )r.   ).0xs     r+   	<genexpr>z_get_ops.<locals>.<genexpr>	  s     =Qa(=s      r   )_state_to_operatorsr   r   r   tupler   r.   len)r4   
op_classesr!   r&   s       r+   r/   r/     s    ,,j,,ZC7C #sCA1vJ  ,j3y"9:=*==C
+C	,s   : AA?>A?c                 R    t        | t        t        t        f      rt	        |       S | S r6   )r   rB   listr   r   )r#   s    r+   r0   r0     s!    #tY/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/   r0   )kvs   00r+   <module>rQ      s    < < < 3 ? ?/ / /  D$<0D$<0D$<0xCc?!;  -2245tq!ad5
aHUp	"O 6s   ?B#