
    Xh%                         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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$d Z%d Z&dS )z}Logic for applying operators to states.

Todo:
* Sometimes the final result needs to be expanded, we should do this by hand.
    )Sum)Add)
NumberKind)Mul)Pow)S)sympify_sympify)AntiCommutator)
Commutator)Dagger)InnerProduct)OuterProductOperator)StateKetBaseBraBaseWavefunction)TensorProductqapplyc                 :    |                      t          d           S )zETransform the inner products in an expression by calling ``.doit()``.c                  8    t          |                                  S N)r   doitargss    n/var/www/tools.fuzzalab.pt/emblema-extractor/venv/lib/python3.11/site-packages/sympy/physics/quantum/qapply.py<lambda>zip_doit_func.<locals>.<lambda>#   s    t1D1I1I1K1K     )replacer   es    r   ip_doit_funcr#   !   s    99\#K#KLLLr   c                 :    |                      t          d           S )z;Transform the sums in an expression by calling ``.doit()``.c                  8    t          |                                  S r   )r   r   r   s    r   r   zsum_doit_func.<locals>.<lambda>(   s    T
(9(9 r   )r    r   r!   s    r   sum_doit_funcr&   &   s    99S99:::r   c                 &   ddl m}                     dd          }                    dd          }                    dd          }t          |           } | j        t
          k    r|rt          |           n| S |                     dd          } t          | t                    r| S t          | t                    r0d}| j        D ]}|t          |fi z  }|                                S t          | |          rfd	| j        D             } || S t          | t                    rt          fd
| j        D              S t          | t                    r7t          t          | j        fi g| j        R  }|rt#          |          n|}|S t          | t$                    rt          | j        fi | j        z  S t          | t*                    r|                                 \  }	}
t+          |	 }t+          |
 }|
s|}n6t          |t*                    r|t/          |fi z  }n|t          |fi z  }|| k    r)|r't1          t/          t1          |           fi           }|rt          |          n|}|rt#          |          n|}|S | S )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).
        * ``sum_doit``: call ``.doit()`` on sums when they are encountered
          (default: False). This is helpful for collapsing sums over Kronecker
          delta's that are created when calling ``qapply``.

    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))
        <b|
    r   )DensitydaggerFsum_doitip_doitT)
commutatortensorproductc                 4    g | ]\  }}t          |fi |fS  r   ).0stateproboptionss      r   
<listcomp>zqapply.<locals>.<listcomp>y   sE     & & & :% E--W--t4 & & &r   c                 *    g | ]}t          |fi S r/   r0   )r1   tr4   s     r   r5   zqapply.<locals>.<listcomp>   s)    DDDva33733DDDr   )sympy.physics.quantum.densityr(   getr
   kindr   r#   expand
isinstancer   r   r   r   r   r   functionlimitsr&   r   baseexpr   args_cnc
qapply_Mulr   )r"   r4   r(   r)   r*   r+   resultargnew_argsc_partnc_partc_mulnc_muls    `           r   r   r   +   s	   V 655555[[5))F{{:u--Hkk)T**GA 	v")0|Aq0 	
D55A !W 3 
As		 .6 	- 	-CfS,,G,,,FF}} 
Aw		 '& & & &f& & &w!! 
A}	%	% !DDDDQVDDDEE 
As		 VAJ22'22>QX>>>*2>v&&& 
As		 af((((!%// 
As		 **,,Vg 	5FF$$ 	5:f88888FF6&44G444FQ;;6;Jvayy<<G<<==F)0<f%%%f*2>v&&&
 r   c                 X  	
 t          | j                  }t          j        }d }t	          |          dk    st          | t                    s| S |                                
|                                	t          
t                    st          
          j
        s)t          	t                    st          	          j
        r| S t          	t                    r8	j        j        r,|                    	j        	j        dz
  z             	j        	t          	t                     r!|                    	j                   	j        	t          
t                     r
j        }
j        
t          	t&          t(          f          r	                                }t          |t,                    rCt/           | j        ||j        d         
gz     | j        ||j        d         
gz    z   fi |z  S t/           | j        | |z  
z  fi |z  S t          	t2                    rt5          d 	j        D                       rt          
t2                    rt5          d 
j        D                       rt	          	j                  t	          
j                  k    ret3          	
fdt7          t	          	j                            D                                  d          }t;           | j        | fi |z  |z  S t          
t<                    rt          	t<                    rt?          	j                   !                    t?          
j                             rtE          d          	j#        
j#        z   }t=          t/          	j$        
j$        z  fi g|R  }t;           | j        | |z  fi S t=          t/          	
j$        z  fi g
j#        R  }t;           | j        | |z  fi S t          	t<                    r=t=          t/          	j$        
z  fi g	j#        R  }t;           | j        | |z  fi S tK          	d	d           }|	  |
fi }n# tL          $ r d }Y nw xY wd }|0tK          
d
d           }|	  |	fi }n# tL          $ r d }Y nw xY w|:t          	tN                    r%t          
tP                    rtS          	
          }t          |tT          tV          tX          f          rt[          |          S |4t	          |          dk    r| S t;           | j        |	gz    fi 
z  |z  S t          |tR                    r|t;           | j        | fi z  |z  S t/           | j        | |z  fi |z  S )N   r   c              3   r   K   | ]2}t          |t          t          t          t          f          p|d k    V  3dS rK   Nr<   r   r   r   r   r1   rD   s     r   	<genexpr>zqapply_Mul.<locals>.<genexpr>   sD      -{-{knjxPSUX>Y.Z.Z.f^aef^f-{-{-{-{-{-{r   c              3   r   K   | ]2}t          |t          t          t          t          f          p|d k    V  3dS rM   rN   rO   s     r   rP   zqapply_Mul.<locals>.<genexpr>   s\        3A  3Aps:cHeUXZ]C^3_3_3kcfjkck  3A  3A  3A  3A  3A  3Ar   c                 \    g | ](}t          j        |         j        |         z  fi )S r/   )r   r   )r1   nlhsr4   rhss     r   r5   zqapply_Mul.<locals>.<listcomp>   s;     j j jPQCHQK(?!K!K7!K!K j j jr   T)r-   z4Duplicated dummy indices in separate sums in qapply._apply_operator_apply_from_right_to).listr   r   Onelenr<   r   popr   r	   is_commutativer   r@   
is_Integerappendr?   r   ketbrar   r   r   r   r   funcr   allranger;   rB   r   set	variablesintersection
ValueErrorr>   r=   getattrNotImplementedErrorr   r   r   intcomplexfloatr
   )r"   r4   r   extrarC   commr>   _apply_apply_rightrT   rU   s    `       @@r   rB   rB      sm   <<DEEF 4yyA~~Z3//~
((**C
((**C sL)) gcll.I C..3:3<<3N #s  2 CHsw{+,,,h #|$$ CGg#|$$ g #
N344 	CxxzzdC   	C1s 3351s 3356    	  &!&$-,S0<<G<<UBB #}%% A#-{-{rurz-{-{-{*{*{ AsM**A/2  3A  3Awzw  3A  3A  3A  0A  0AAMMS]]** j j j j j jUZ[^_b_g[h[hUiUi j j jkrr  BFr  G  G&!&$-33733F:5@@ #s 	?c3 	?3=!!..s3=/A/ABB Y !WXXXZ#*,FS\ 9EEWEEOOOOFfafdmF2>>g>>>CL 0<<G<<JszJJJFfafdmF2>>g>>>#s ;VCL,8888F3:FFF&!&$-.::'::: S+T22F	VC++7++FF" 	 	 	FFF	 ~s$:DAA#%c55W55&    ~c7## 	,
3(@(@ 	,!#s++F &3/00 =	t99>>Hfaftse|5AAAA#EeKK	FL	)	) =j::':::5@@fafdmF*66g66u<<s$   .	Q8 8RR"	R, ,R;:R;N)'__doc__sympy.concreter   sympy.core.addr   sympy.core.kindr   sympy.core.mulr   sympy.core.powerr   sympy.core.singletonr   sympy.core.sympifyr	   r
   $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   rB   r/   r   r   <module>r      s                & & & & & &                   " " " " " " 0 0 0 0 0 0 0 0 ? ? ? ? ? ? 7 7 7 7 7 7 / / / / / / ; ; ; ; ; ; A A A A A A A A M M M M M M M M M M M M = = = = = = M M M
; ; ;
t t tne= e= e= e= e=r   