Ë
    7^(hý  ã                   óŒ   — 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	„ Zd
„ Zd„ Z G d„ de«      Zy)é    )ÚAdd)ÚTuple)ÚExpr)ÚMul)ÚPow)Údefault_sort_key)Úsympify)ÚMatrixc                 óÌ   — t        | «      } t        | t        «      rI| j                  s<| j                  s0| j
                  s$| j                  s| j                  r| j                  ryy)z Helper method used in TrTF)	r	   Ú
isinstancer   Ú
is_IntegerÚis_FloatÚis_RationalÚ	is_NumberÚ	is_SymbolÚis_commutative)Úes    úY/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/physics/quantum/trace.pyÚ
_is_scalarr      sF   € ô 	�‹
€AÜ�!”TÔØ�LŠL˜AŸJšJØ�MŠM˜QŸ[š[Ø�[Š[˜Q×-Ò-ààó    c                 óà  — t        | «      dk(  r| S t        | t        ¬«      }t        | «      D ��cg c]  \  }}||k(  sŒ|‘Œ }}}t	        | «      }|j                  | «       |j                  t        | «      |d   z   «       t        t        |«      dz
  «      D �cg c]  }|||   ||dz       g‘Œ }}|j                  t        |«      «      }|||   ||   t        | «      z    }|S c c}}w c c}w )a5   Cyclic permutations based on canonical ordering

    Explanation
    ===========

    This method does the sort based ascii values while
    a better approach would be to used lexicographic sort.

    TODO: Handle condition such as symbols have subscripts/superscripts
    in case of lexicographic sort

    é   )Úkeyr   )	ÚlenÚminr   Ú	enumerateÚlistÚextendÚappendÚrangeÚindex)	ÚlÚmin_itemÚiÚxÚindicesÚleÚsublistÚidxÚ	ordered_ls	            r   Ú_cycle_permuter+      sñ   € ô ˆ1ƒv�‚{Øˆä�1Ô*Ô+€HÜ& q›\×;‘T�Q˜¨Q°(«]ŠqÐ;€GÑ;ä	ˆa‹€BØ‡I�Iˆa„Lð ‡N�N”3�q“6˜G A™JÑ&Ô'ô ”S˜“\ AÑ%Ó&ö(°1��7˜1‘:˜g a¨!¡e™nÐ-Ò.ð (€Gð (ð
 �-‰-œ˜G›Ó
%€CØ�7˜3‘< ¨¡¬s°1«vÑ 5Ð6€IàÐùó' <ùò(s   °C%¾C%ÂC+c                 óŠ   — t        | «      dk(  r| S t        | dd «      }|j                  | dd «       t        |Ž j                  S )zk this just moves the last arg to first position
     to enable expansion of args
     A,B,A ==> A**2,B
    r   éÿÿÿÿNr   )r   r   r   r   Úargs)r"   r%   s     r   Ú_rearrange_argsr/   B   sC   € ô
 ˆ1ƒv�‚{ØˆäˆQˆrˆsˆV‹€AØ‡H�HˆQˆq�ˆWÔÜ�ˆ7�<‰<Ðr   c                   óH   — e Zd ZdZd„ Zed„ «       Zd„ Zed„ «       Zd„ Z	d„ Z
y)	ÚTra‚   Generic Trace operation than can trace over:

    a) SymPy matrix
    b) operators
    c) outer products

    Parameters
    ==========
    o : operator, matrix, expr
    i : tuple/list indices (optional)

    Examples
    ========

    # TODO: Need to handle printing

    a) Trace(A+B) = Tr(A) + Tr(B)
    b) Trace(scalar*Operator) = scalar*Trace(Operator)

    >>> from sympy.physics.quantum.trace import Tr
    >>> from sympy import symbols, Matrix
    >>> a, b = symbols('a b', commutative=True)
    >>> A, B = symbols('A B', commutative=False)
    >>> Tr(a*A,[2])
    a*Tr(A)
    >>> m = Matrix([[1,2],[1,1]])
    >>> Tr(m)
    2

    c           	      óè  — t        |«      dk(  r>t        |d   t        t        t        f«      st        |d   «      }nt        |d   Ž }|d   }n)t        |«      dk(  rt        «       }|d   }nt        d«      ‚t        |t        «      r|j                  «       S t        |d«      r%t        |j                  «      r|j                  «       S t        |t        «      r*t        |j                  D �cg c]  }t        ||«      ‘Œ c}Ž S t        |t        «      ra|j                  «       \  }}t        |«      dk(  rt        |Ž S t        j                   | t        |Ž |«      }t        |«      dkD  rt        |Ž |z  S |S t        |t"        «      rIt%        |j                  d   «      rt%        |j                  d   «      r|S t        j                   | ||«      S t%        |«      r|S t        j                   | ||«      S c c}w )z� Construct a Trace object.

        Parameters
        ==========
        args = SymPy expression
        indices = tuple/list if indices, optional

        é   r   r   z5Arguments to Tr should be of form (expr[, [indices]])Útrace)r   r   r   r   ÚtupleÚ
ValueErrorr
   r4   ÚhasattrÚcallabler   r.   r1   r   Úargs_cncr   Ú__new__r   r   )Úclsr.   r&   ÚexprÚargÚc_partÚnc_partÚobjs           r   r:   z
Tr.__new__n   s¥  € ô �‹I˜ŠNÜ˜d 1™g¬¬e´UÐ';Ô<Ü  Q¡›.‘ä  a¡˜/�à˜‘7‰DÜ�$‹i˜1ŠnÜ“gˆGØ˜‘7‰Däð 3ó 4ð 4ô �dœFÔ#Ø—:‘:“<ÐÜ�T˜7Ô#¬°·±Ô(<à—:‘:“<ÐÜ˜œcÔ"Ü°T·Y±YÖ?¨cœ˜C Õ)Ò?Ð@Ð@Ü˜œcÔ"Ø"Ÿm™m›o‰OˆF�GÜ�7‹|˜qÒ Ü˜F�|Ð#ä—l‘l 3¬¨W¨°wÓ@�ô ,/¨v«;¸ª?”s˜F�| CÑ'ÐCÀÐCÜ˜œcÔ"Ü˜4Ÿ9™9 Q™<Ô(Ü˜tŸy™y¨™|Ô,Ø�ä—|‘| C¨¨wÓ7Ð7ä˜4Ô Ø�ä—<‘<  T¨7Ó3Ð3ùò) @s   Ã*G/c                 óP   — | j                   d   }|j                  }|j                  S )Nr   )r.   ÚkindÚelement_kind)Úselfr<   Ú	expr_kinds      r   rB   zTr.kind£   s$   € à�y‰y˜‰|ˆØ—I‘Iˆ	Ø×%Ñ%Ð%r   c                 ó�   — t        | j                  d   d«      r,| j                  d   j                  | j                  d   ¬«      S | S )a†   Perform the trace operation.

        #TODO: Current version ignores the indices set for partial trace.

        >>> from sympy.physics.quantum.trace import Tr
        >>> from sympy.physics.quantum.operator import OuterProduct
        >>> from sympy.physics.quantum.spin import JzKet, JzBra
        >>> t = Tr(OuterProduct(JzKet(1,1), JzBra(1,1)))
        >>> t.doit()
        1

        r   Ú_eval_tracer   )r&   )r7   r.   rG   )rD   Úhintss     r   ÚdoitzTr.doit©   s?   € ô �4—9‘9˜Q‘< Ô/Ø—9‘9˜Q‘<×+Ñ+°D·I±I¸a±LÐ+ÓAÐAàˆr   c                  ó   — y)NT© )rD   s    r   Ú	is_numberzTr.is_number»   s   € ð r   c                 ó`  — |dkD  r&|t        | j                  d   j                  «      z  }n/t        |«      t        | j                  d   j                  «      z   }t        | j                  d   j                  | d | j                  d   j                  d|  z   «      }t	        t        |Ž «      S )aÌ   Permute the arguments cyclically.

        Parameters
        ==========

        pos : integer, if positive, shift-right, else shift-left

        Examples
        ========

        >>> from sympy.physics.quantum.trace import Tr
        >>> from sympy import symbols
        >>> A, B, C, D = symbols('A B C D', commutative=False)
        >>> t = Tr(A*B*C*D)
        >>> t.permute(2)
        Tr(C*D*A*B)
        >>> t.permute(-2)
        Tr(C*D*A*B)

        r   N)r   r.   Úabsr   r1   r   )rD   Úposr.   s      r   Úpermutez
Tr.permuteÂ   s˜   € ð* �Š7Øœ˜DŸI™I a™L×-Ñ-Ó.Ñ.‰Cä˜“Hœs 4§9¡9¨Q¡<×#4Ñ#4Ó5Ñ5Ð6ˆCä�D—I‘I˜a‘L×%Ñ% s d eÐ,¨t¯y©y¸©|×/@Ñ/@ÀÀCÀ4Ð/HÑHÓIˆä”#˜�,ÓÐr   c                 óì   — t        | j                  d   t        «      r,t        t	        | j                  d   j                  «      «      }n| j                  d   g}t        |«      | j                  d   fz   S )Nr   r   )r   r.   r   r+   r/   r5   )rD   r.   s     r   Ú_hashable_contentzTr._hashable_contentà   sZ   € Ü�d—i‘i ‘l¤CÔ(Ü!¤/°$·)±)¸A±,×2CÑ2CÓ"DÓE‰Dà—I‘I˜a‘L�>ˆDä�T‹{˜dŸi™i¨™lÐ-Ñ-Ð-r   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r:   ÚpropertyrB   rI   rL   rP   rR   rK   r   r   r1   r1   O   sD   „ ñò<34ðj ñ&ó ð&ò
ð$ ñó ðò ó<.r   r1   N)Úsympy.core.addr   Úsympy.core.containersr   Úsympy.core.exprr   Úsympy.core.mulr   Úsympy.core.powerr   Úsympy.core.sortingr   Úsympy.core.sympifyr	   Úsympy.matricesr
   r   r+   r/   r1   rK   r   r   ú<module>r`      s;   ðÝ Ý 'Ý  Ý Ý  Ý /Ý &Ý !òò%òP
ôW.ˆõ W.r   