U
    ZÊ¹jR  ã                   @   s¾   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d„ Zd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.
é    )ÚAdd)ÚMul)ÚPow)ÚS)Úsympify)ÚAntiCommutator)Ú
Commutator)ÚDagger)ÚInnerProduct)ÚOuterProductÚOperator)ÚStateÚKetBaseÚBraBaseÚWavefunction)ÚTensorProductÚqapplyc                    sb  ddl m} ˆ  dd¡}| dkr&tjS | jddd�} t| tƒrB| S t| tƒrtd}| j	D ]}|t
|fˆ Ž7 }qV| ¡ S t| |ƒrš‡ fdd„| j	D ƒ}||Ž S t| tƒr¼t‡ fd	d„| j	D ƒŽ S t| tƒrÚt
| jfˆ Ž| j S t| tƒ�rZ|  ¡ \}}t|Ž }	t|Ž }
t|
tƒ�r |	t|
fˆ Ž }n|	t
|
fˆ Ž }|| k�rT|�rTttt| ƒfˆ ŽƒS |S n| S d
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).

    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)Z
commutatorÚtensorproductc                    s    g | ]\}}t |fˆ Ž|f‘qS © ©r   )Ú.0ÚstateZprob©Úoptionsr   ú[/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/physics/quantum/qapply.pyÚ
<listcomp>e   s    ÿzqapply.<locals>.<listcomp>c                    s   g | ]}t |fˆ Ž‘qS r   r   )r   Útr   r   r   r   k   s     N)Zsympy.physics.quantum.densityr   Úgetr   ÚZeroÚexpandÚ
isinstancer   r   Úargsr   r   r   ÚbaseÚexpr   Zargs_cncÚ
qapply_Mulr	   )Úer   r   r   ÚresultÚargÚnew_argsZc_partZnc_partZc_mulZnc_mulr   r   r   r      s@    *




ÿ

c                    s  ˆ  dd¡}t| jƒ}t|ƒdks,t| tƒs0| S | ¡ ‰| ¡ ‰ tˆtƒsTtˆƒj	shtˆ tƒsltˆ ƒj	rl| S tˆ t
ƒršˆ jjrš| ˆ jˆ jd  ¡ ˆ j‰ tˆ tƒr¶| ˆ j¡ ˆ j‰ tˆ ttfƒ�r,ˆ  ¡ }t|tƒ�rt| j||jd ˆg Ž | j||jd ˆg Ž  fˆŽS t| j|Ž | ˆ fˆŽS tˆ tƒ�rÈtdd„ ˆ jD ƒƒ�rÈtˆtƒ�rÈtdd„ ˆjD ƒƒ�rÈtˆ jƒtˆjƒk�rÈt‡ ‡‡fdd	„ttˆ jƒƒD ƒŽ jdd
�}t| j|Ž fˆŽ| S zˆ jˆfˆŽ}W n tk
�rô   d }Y nX |d k�rBtˆdd ƒ}|d k	�rBz|ˆ fˆŽ}W n tk
�r@   d }Y nX |d k�r|tˆ t ƒ�r|tˆt!ƒ�r|t"ˆ ˆƒ}|�r|| ¡ }|dk�rŒt#j$S |d k�rÆt|ƒdk�r¨| S t| j|ˆ g Ž fˆŽˆ S n8t|t"ƒ�rè|t| j|Ž fˆŽ S t| j|Ž | fˆŽS d S )NÚip_doitTé   r   c                 s   s(   | ] }t |ttttfƒp|d kV  qdS ©r,   N©r"   r   r   r   r   ©r   r)   r   r   r   Ú	<genexpr>®   s     zqapply_Mul.<locals>.<genexpr>c                 s   s(   | ] }t |ttttfƒp|d kV  qdS r-   r.   r/   r   r   r   r0   ¯   s     c                    s(   g | ] }t ˆ j| ˆj|  fˆŽ‘qS r   )r   r#   )r   Ún©Úlhsr   Úrhsr   r   r   ±   s     zqapply_Mul.<locals>.<listcomp>)r   Z_apply_from_right_to)%r   Úlistr#   Úlenr"   r   Úpopr   r   Zis_commutativer   r%   Z
is_IntegerÚappendr$   r   ZketZbrar   r   Zdoitr   r   Úfuncr   ÚallÚranger!   r&   Z_apply_operatorÚNotImplementedErrorÚgetattrr   r   r
   r   r    )r'   r   r+   r#   Zcommr(   Z_apply_rightr   r2   r   r&   …   s~    
ÿÿ
ÿÿý"ÿÿþ,







r&   N) Ú__doc__Zsympy.core.addr   Zsympy.core.mulr   Zsympy.core.powerr   Zsympy.core.singletonr   Zsympy.core.sympifyr   Z$sympy.physics.quantum.anticommutatorr   Z sympy.physics.quantum.commutatorr   Zsympy.physics.quantum.daggerr	   Z"sympy.physics.quantum.innerproductr
   Zsympy.physics.quantum.operatorr   r   Zsympy.physics.quantum.stater   r   r   r   Z#sympy.physics.quantum.tensorproductr   Ú__all__r   r&   r   r   r   r   Ú<module>   s    ÿ	g