
    sgR                         d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	m
Z
 ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZmZ ddlmZmZmZmZ ddlmZ dgZd Zd Zy)z}Logic for applying operators to states.

Todo:
* Sometimes the final result needs to be expanded, we should do this by hand.
    )Add)Mul)Pow)S)sympify)AntiCommutator)
Commutator)Dagger)InnerProduct)OuterProductOperator)StateKetBaseBraBaseWavefunction)TensorProductqapplyc           
         ddl m} |j                  dd      }| dk(  rt        j                  S | j                  dd      } t        | t              r| S t        | t              r2d}| j                  D ]  }|t        |fi |z  } |j                         S t        | |      r/| j                  D cg c]  \  }}t        |fi ||f }}} || S t        | t              r*t        | j                  D 	cg c]  }	t        |	fi | c}	 S t        | t              r#t        | j                  fi || j                  z  S t        | t              ry| j!                         \  }
}t        |
 }t        | }t        |t              r|t#        |fi |z  }n|t        |fi |z  }|| k(  r |rt%        t#        t%        |       fi |      S |S | S c c}}w c c}	w )a_  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>
    r   )DensitydaggerFT)
commutatortensorproduct)sympy.physics.quantum.densityr   getr   Zeroexpand
isinstancer   r   argsr   r   r   baseexpr   args_cnc
qapply_Mulr
   )eoptionsr   r   resultargstateprobnew_argstc_partnc_partc_mulnc_muls                 O/var/www/html/venv/lib/python3.12/site-packages/sympy/physics/quantum/qapply.pyr   r      s   T 6[[5)FAvvv 	
D5A !W 
As	66 	-CfS,G,,F	-}} 
Aw	ff& :% E-W-t4 & &!! 
A}	%QVVDva373DEE 
As	aff((!%%// 
As	**,Vgfc":f888F6&4G44FQ;6*VAY:':;;M
 ;& Es   0G3Gc           
      .   |j                  dd      }t        | j                        }t        |      dk  st	        | t
              s| S |j                         }|j                         }t	        |t              st        |      j                  s%t	        |t              st        |      j                  r| S t	        |t              rM|j                  j                  r7|j                  |j                  |j                  dz
  z         |j                  }t	        |t              r'|j                  |j                          |j"                  }t	        |t$        t&        f      r|j)                         }t	        |t*              rMt-         | j.                  ||j                  d   |gz     | j.                  ||j                  d   |gz    z   fi |S t-         | j.                  | |z  |z  fi |S t	        |t0              rt3        d |j                  D              rt	        |t0              rt3        d |j                  D              rt        |j                        t        |j                        k(  rt1        t5        t        |j                              D cg c]+  }t-        |j                  |   |j                  |   z  fi |- c} j7                  d      }t9         | j.                  | fi ||z  S 	  |j:                  |fi |}|t?        |dd       }	|	
	  |	|fi |}|>t	        |t@              r.t	        |tB              rtE        ||      }|r|j)                         }|dk(  rtF        jH                  S |0t        |      dk(  r| S t9         | j.                  ||gz    fi ||z  S t	        |tD              r|t9         | j.                  | fi |z  S t-         | j.                  | |z  fi |S c c}w # t<        $ r d }Y w xY w# t<        $ r d }Y w xY w)	Nip_doitT   r   c              3   j   K   | ]+  }t        |t        t        t        t        f      xs |d k(   - ywr2   Nr   r   r   r   r   .0r&   s     r/   	<genexpr>zqapply_Mul.<locals>.<genexpr>   s2     -{knjxPSUX>Y.Z.f^aef^f.f-{   13c              3   j   K   | ]+  }t        |t        t        t        t        f      xs |d k(   - ywr4   r5   r6   s     r/   r8   zqapply_Mul.<locals>.<genexpr>   s8       3Aps:cHeUXZ]C^3_3kcfjkck3k  3Ar9   )r   _apply_from_right_to)%r   listr   lenr   r   popr   r   is_commutativer   r    
is_Integerappendr   r   ketbrar	   r   doitr   r   funcr   allranger   r"   _apply_operatorNotImplementedErrorgetattrr   r   r   r   r   )
r#   r$   r1   r   rhslhscommnr%   _apply_rights
             r/   r"   r"      s   kk)T*G<D 4yA~Z3/
((*C
((*C sL)gcl.I.IC.73<3N3N #s 2 2CHHsww{+,hh #|$CGGgg #
N34xxzdC 1s 3351s 3356   &!&&$-,S0<G<< #}%#-{rurzrz-{*{sM*s  3Awzww  3A  0AMS]*UZ[^_b_g_g[hUi jPQCHHQK(?!K7!K jkrr  BFr  G&!&&$-373F::$$$S4G4 ~s$:DA#%c5W5 ~c7#
3(@!#s+F {vv	t9>Hfafftse|5AA#EE	FL	)j:':::faffdmF*6g66G !k   ' s*   0O03O5 	P 5PPPPN) __doc__sympy.core.addr   sympy.core.mulr   sympy.core.powerr   sympy.core.singletonr   sympy.core.sympifyr   $sympy.physics.quantum.anticommutatorr    sympy.physics.quantum.commutatorr	   sympy.physics.quantum.daggerr
   "sympy.physics.quantum.innerproductr   sympy.physics.quantum.operatorr   r   sympy.physics.quantum.stater   r   r   r   #sympy.physics.quantum.tensorproductr   __all__r   r"        r/   <module>r`      sL        " & ? 7 / ; A M M = dNO7r_   