Ë
    7^(h%  ã                   óâ   — 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&y)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                 ó0   — | j                  t        d„ «      S )zETransform the inner products in an expression by calling ``.doit()``.c                  ó.   — t        | Ž j                  «       S ©N)r   Údoit©Úargss    úZ/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/physics/quantum/qapply.pyú<lambda>zip_doit_func.<locals>.<lambda>#   s   € ´¸tÐ1D×1IÑ1IÓ1K€ ó    )Úreplacer   ©Úes    r   Úip_doit_funcr#   !   s   € à�9‰9”\Ñ#KÓLÐLr   c                 ó0   — | j                  t        d„ «      S )z;Transform the sums in an expression by calling ``.doit()``.c                  ó.   — t        | Ž j                  «       S r   )r   r   r   s    r   r   zsum_doit_func.<locals>.<lambda>(   s   € ¬¨T¨
¯©Ó(9€ r   )r    r   r!   s    r   Úsum_doit_funcr&   &   s   € à�9‰9”SÑ9Ó:Ð:r   c           
      ó  — ddl m} |j                  dd«      }|j                  dd«      }|j                  dd«      }t        | «      } | j                  t
        k(  r|rt        | «      S | 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        t        | j                  fi |¤Žg| j                   ¢­Ž }|rt#        |«      }|S |}|S t        | t$        «      r#t        | j&                  fi |¤Ž| j(                  z  S t        | t*        «      rž| j-                  «       \  }}t+        |Ž }t+        |Ž }|s|}n/t        |t*        «      r|t/        |fi |¤Žz  }n|t        |fi |¤Žz  }|| k(  r |rt1        t/        t1        | «      fi |¤Ž«      }|rt        |«      n|}|rt#        |«      }|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).
        * ``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Útensorproduct)Úsympy.physics.quantum.densityr(   Úgetr
   Úkindr   r#   ÚexpandÚ
isinstancer   r   r   r   r   r   ÚfunctionÚlimitsr&   r   ÚbaseÚexpr   Úargs_cncÚ
qapply_Mulr   )r"   Úoptionsr(   r)   r*   r+   ÚresultÚargÚstateÚprobÚnew_argsÚtÚc_partÚnc_partÚc_mulÚnc_muls                   r   r   r   +   s€  € õV 6à�[‰[˜ 5Ó)€FØ�{‰{˜: uÓ-€HØ�k‰k˜) TÓ*€Gä�‹€Að 	‡v�v”ÒÙ")Œ|˜A‹Ð0¨qÐ0ð 	
�‰˜D°ˆÓ5€Aô �!”WÔØˆô 
�A”sÔ	ØˆØ—6‘6ò 	-ˆCØ”f˜SÑ, GÑ,Ñ,‰Fð	-à�}‰}‹Ðô 
�A�wÔ	àŸf™f÷&ñ :¸%Øô ˜EÑ- WÑ-¨tÒ4ð &ˆñ &á˜Ð!Ð!ô 
�A”}Ô	%Ü¸Q¿V¹VÖD¸œv aÑ3¨7Ó3ÒDÐEÐEô 
�A”sÔ	Ü”V˜AŸJ™JÑ2¨'Ñ2Ð>°Q·X±XÒ>ˆÙ*2”˜vÓ&ˆØˆð 9?ˆØˆô 
�A”sÔ	Ü�a—f‘fÑ( Ñ(¨!¯%©%Ñ/Ð/ô 
�A”sÔ	ØŸ*™*›,‰ˆ�Ü�V�ˆÜ�g�ˆÙØ‰FÜ˜¤Ô$Øœ: fÑ8°Ñ8Ñ8‰Fàœ6 &Ñ4¨GÑ4Ñ4ˆFØ�QŠ;™6ÜœJ¤v¨a£yÑ<°GÑ<Ó=ˆFÙ)0”˜fÔ%°fˆÙ*2”˜vÓ&ˆØˆð 9?ˆØˆð
 ˆùóM&ùò Es   Ã,I6Ä/I<c           
      ó~  — t        | j                  «      }t        j                  }d }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         «      r|j$                  }|j"                  }t        |t&        t(        f«      r’|j+                  «       }t        |t,        «      rPt/         | j0                  ||j                  d   |gz   Ž  | j0                  ||j                  d   |gz   Ž z   fi |¤Ž|z  S t/         | j0                  |Ž |z  |z  fi |¤Ž|z  S t        |t2        «      rût5        d„ |j                  D «       «      rßt        |t2        «      rÏt5        d„ |j                  D «       «      r³t	        |j                  «      t	        |j                  «      k(  rˆt3        t7        t	        |j                  «      «      D �cg c]+  }t/        |j                  |   |j                  |   z  fi |¤Ž‘Œ- c}Ž j9                  d¬«      }t;         | j0                  |Ž fi |¤Ž|z  |z  S t        |t<        «      rýt        |t<        «      r¤t?        |j@                  «      jC                  t?        |j@                  «      «      rtE        d«      ‚|jF                  |jF                  z   }	t=        t/        |jH                  |jH                  z  fi |¤Žg|	¢­Ž }t;         | j0                  |Ž |z  fi |¤ŽS t=        t/        ||jH                  z  fi |¤Žg|jF                  ¢­Ž }t;         | j0                  |Ž |z  fi |¤ŽS t        |t<        «      rIt=        t/        |jH                  |z  fi |¤Žg|jF                  ¢­Ž }t;         | j0                  |Ž |z  fi |¤ŽS tK        |dd «      }
|
�	  |
|fi |¤Ž}nd }|€tK        |d	d «      }|�
	  ||fi |¤Ž}|€,t        |tN        «      rt        |tP        «      rtS        ||«      }t        |tT        tV        tX        f«      rt[        |«      S |€3t	        |«      dk(  r| S t;         | j0                  ||gz   Ž fi |¤Ž|z  |z  S t        |tR        «      r|t;         | j0                  |Ž fi |¤Žz  |z  S t/         | j0                  |Ž |z  fi |¤Ž|z  S c c}w # tL        $ r d }Y �Œw xY w# tL        $ r d }Y Œûw xY w)
Né   r   c              3   ój   K  — | ]+  }t        |t        t        t        t        f«      xs |d k(  –— Œ- y­w©rE   N©r2   r   r   r   r   ©Ú.0r;   s     r   ú	<genexpr>zqapply_Mul.<locals>.<genexpr>Ï   s2   è ø€ Ò-{Ðkn¬j¸¼xÌÔPSÔUXÐ>YÓ.ZÒ.fÐ^aÐefÑ^fÓ.fÑ-{ùó   ‚13c              3   ój   K  — | ]+  }t        |t        t        t        t        f«      xs |d k(  –— Œ- y­wrG   rH   rI   s     r   rK   zqapply_Mul.<locals>.<genexpr>Ð   s8   è ø€ ò  3AÐps´:¸cÄHÌeÔUXÔZ]ÐC^Ó3_Ò3kÐcfÐjkÑckÓ3kñ  3AùrL   T)r-   z4Duplicated dummy indices in separate sums in qapply.Ú_apply_operatorÚ_apply_from_right_to).Úlistr   r   ÚOneÚlenr2   r   Úpopr   r	   Úis_commutativer   r6   Ú
is_IntegerÚappendr5   r   ÚketÚbrar   r   r   r   r   Úfuncr   ÚallÚranger1   r8   r   ÚsetÚ	variablesÚintersectionÚ
ValueErrorr4   r3   ÚgetattrÚNotImplementedErrorr   r   r   ÚintÚcomplexÚfloatr
   )r"   r9   r   Úextrar:   ÚrhsÚlhsÚcommÚnr4   Ú_applyÚ_apply_rights               r   r8   r8   ¢   s-  € ä�—‘‹<€DÜ�E‰E€EØ€Fô ˆ4ƒy�A‚~œZ¨¬3Ô/ØˆØ
�(‰(‹*€CØ
�(‰(‹*€Cô �sœLÔ)¬g°c«l×.IÒ.IÜ˜C¤Ô.´7¸3³<×3NÒ3NØˆô �#”sÔ §¡× 2Ò 2Ø�‰�C—H‘H˜sŸw™w¨™{Ñ+Ô,Ø�h‰hˆô �#”|Ô$Ø�‰�C—G‘GÔØ�g‰gˆä�#”|Ô$Ø—‘ˆØ�g‰gˆô �#œ
¤NÐ3Ô4Ø�x‰x‹zˆÜ�dœCÔ ÜØ�—‘˜ §¡¨1¡¨sÐ 3Ñ3Ð5Ø�—‘˜ §¡¨1¡¨sÐ 3Ñ3Ð5ñ6ñð ñð ñ	ð ô ˜&˜!Ÿ&™& $˜-¨Ñ,¨SÑ0Ñ<°GÑ<¸UÑBÐBô �#”}Ô%¬#Ñ-{Ðru×rzÑrzÔ-{Ô*{Ü�sœMÔ*¬sñ  3AÐwz×wÑwô  3Aô  0AÜ�—‘‹MœS §¡›]Ò*ÜÔUZÔ[^Ð_b×_gÑ_gÓ[hÓUiÖ jÐPQ¤¨¯©°©°C·H±H¸Q±KÑ(?Ñ!KÀ7Ó!KÒ jÐk×rÑrð  BFÐró  GˆÜ˜&˜!Ÿ&™& $˜-Ñ3¨7Ñ3°FÑ:¸5Ñ@Ð@ô �#”sÔÜ�cœ3ÔÜ�3—=‘=Ó!×.Ñ.¬s°3·=±=Ó/AÔBÜ Ð!WÓXÐXØ—Z‘Z #§*¡*Ñ,ˆFÜœ §¡¨S¯\©\Ñ 9ÑE¸WÑEÐOÈÒOˆFÜ˜f˜aŸf™f d˜m¨FÑ2Ñ>°gÑ>Ð>äœ  C§L¡LÑ 0Ñ<°GÑ<ÐJ¸s¿z¹zÒJˆFÜ˜f˜aŸf™f d˜m¨FÑ2Ñ>°gÑ>Ð>ä�#”sÔÜ”V˜CŸL™L¨Ñ,Ñ8°Ñ8ÐF¸3¿:¹:ÒFˆÜ˜&˜!Ÿ&™& $˜-¨Ñ.Ñ:°'Ñ:Ð:ô �SÐ+¨TÓ2€FØÐð	Ù˜CÑ+ 7Ñ+‰Fð ˆà€~Ü˜sÐ$:¸DÓAˆØÐ#ðÙ% cÑ5¨WÑ5�ð €~Ü�cœ7Ô#¬
°3¼Ô(@Ü! # sÓ+ˆFô �&œ3¤¬Ð/Ô0Ü˜ÓÐØ	ˆÜˆt‹9˜Š>àˆHä˜f˜aŸf™f t¨s¨e¡|Ð5ÑA¸ÑAÀ#ÑEÀeÑKÐKÜ	�FœLÔ	)Ø”j  §¡¨ Ñ:°'Ñ:Ñ:¸5Ñ@Ð@ä�f�a—f‘f˜d�m FÑ*Ñ6¨gÑ6°uÑ<Ð<ùòk !køô0 #ò 	Ø‹Fð	ûô 'ò Ø’ðús*   Ë 0VÒ	V Ò7	V. ÖV+Ö*V+Ö.V<Ö;V<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   r8   © r   r   ú<module>r}      s]   ðñõ Ý Ý &Ý Ý  Ý "ß 0å ?Ý 7Ý /Ý ;ß Aß MÓ MÝ =ð ð€òMò
;ò
tóne=r   