§
    º³Ùg&  ã                  óš   — d Z ddlmZ ddlZddlmZ ddlmZ ddl	m
Z
 ddlmZmZmZmZ 	 ddd„Zddd„Zddd„Zddd„Zd d„Zd d„Zd„ ZdS )!zJ
Quantum information measures, metrics, and related functions for states.
é    )ÚannotationsN)ÚQiskitError)ÚStatevector)ÚDensityMatrix)Úpartial_traceÚshannon_entropyÚ_format_stateÚ	_funm_svdTÚstate1úStatevector | DensityMatrixÚstate2ÚvalidateÚboolÚreturnÚfloatc                ó^  — t          | |¬¦  «        } t          ||¬¦  «        }| j        }|j        }t          | t          ¦  «        r�t          |t          ¦  «        r=t	          j        |                     ¦   «                              |¦  «        ¦  «        dz  }nö|                     ¦   «                              |¦  «                             |¦  «        }n»t          |t          ¦  «        r;|                     ¦   «                              |¦  «                             |¦  «        }nkt          |t          j	        ¦  «        }t          |t          j	        ¦  «        }t          j
                             |                     |¦  «        d¬¦  «        dz  }t          t	          j        |¦  «        ¦  «        S )aq  Return the state fidelity between two quantum states.

    The state fidelity :math:`F` for density matrix input states
    :math:`\rho_1, \rho_2` is given by

    .. math::
        F(\rho_1, \rho_2) = Tr[\sqrt{\sqrt{\rho_1}\rho_2\sqrt{\rho_1}}]^2.

    If one of the states is a pure state this simplifies to
    :math:`F(\rho_1, \rho_2) = \langle\psi_1|\rho_2|\psi_1\rangle`, where
    :math:`\rho_1 = |\psi_1\rangle\!\langle\psi_1|`.

    Args:
        state1 (Statevector or DensityMatrix): the first quantum state.
        state2 (Statevector or DensityMatrix): the second quantum state.
        validate (bool): check if the inputs are valid quantum states
                         [Default: True]

    Returns:
        float: The state fidelity :math:`F(\rho_1, \rho_2)`.

    Raises:
        QiskitError: if ``validate=True`` and the inputs are invalid quantum states.
    ©r   é   Únuc)Úord)r	   ÚdataÚ
isinstancer   ÚnpÚabsÚconjÚdotr
   ÚsqrtÚlinalgÚnormr   Úreal)r   r   r   Úarr1Úarr2ÚfidÚs1sqÚs2sqs           úY/granary/edev/quantum/lib/python3.11/site-packages/qiskit/quantum_info/states/measures.pyÚstate_fidelityr'      sL  € õ8 ˜6¨HÐ5Ñ5Ô5€FÝ˜6¨HÐ5Ñ5Ô5€Fð Œ;€DØŒ;€DÝ�&�+Ñ&Ô&ð =Ý�f�kÑ*Ô*ð 	2å”&˜Ÿš™œŸš¨Ñ.Ô.Ñ/Ô/°1Ñ4ˆCˆCð —)’)‘+”+—/’/ $Ñ'Ô'×+Ò+¨DÑ1Ô1ˆCˆCÝ	�F�KÑ	(Ô	(ð =à�iŠi‰kŒk�oŠo˜dÑ#Ô#×'Ò'¨Ñ-Ô-ˆˆõ ˜�rœwÑ'Ô'ˆÝ˜�rœwÑ'Ô'ˆÝŒi�nŠn˜TŸXšX d™^œ^°ˆnÑ7Ô7¸1Ñ<ˆå•”˜‘”ÑÔÐó    Ústatec                óL   — t          | |¬¦  «        } |                      ¦   «         S )a³  Calculate the purity of a quantum state.

    The purity of a density matrix :math:`\rho` is

    .. math::

        \text{Purity}(\rho) = Tr[\rho^2]

    Args:
        state (Statevector or DensityMatrix): a quantum state.
        validate (bool): check if input state is valid [Default: True]

    Returns:
        float: the purity :math:`Tr[\rho^2]`.

    Raises:
        QiskitError: if the input isn't a valid quantum state.
    r   )r	   Úpurity)r)   r   s     r&   r+   r+   R   s$   € õ& ˜%¨(Ð3Ñ3Ô3€EØ�<Š<‰>Œ>Ðr(   r   ÚbaseÚintc                óþ   — ddl m} t          | d¬¦  «        } t          | t          ¦  «        rdS t          j        t          j        |                     | j	        ¦  «        ¦  «        d¦  «        }t          ||¬¦  «        S )a®  Calculate the von-Neumann entropy of a quantum state.

    The entropy :math:`S` is given by

    .. math::

        S(\rho) = - Tr[\rho \log(\rho)]

    Args:
        state (Statevector or DensityMatrix): a quantum state.
        base (int): the base of the logarithm [Default: 2].

    Returns:
        float: The von-Neumann entropy S(rho).

    Raises:
        QiskitError: if the input state is not a valid QuantumState.
    r   NTr   ç        ©r,   )Úscipy.linalgr   r	   r   r   r   Úmaximumr    Úeigvalsr   r   )r)   r,   ÚlaÚevalss       r&   Úentropyr6   i   s{   € ð& ÐÐÐÐÐå˜%¨$Ð/Ñ/Ô/€EÝ�%�Ñ%Ô%ð ØˆqåŒJ•r”w˜rŸzšz¨%¬*Ñ5Ô5Ñ6Ô6¸Ñ<Ô<€EÝ˜5 tÐ,Ñ,Ô,Ð,r(   c                ó:  — t          | d¬¦  «        } t          |                      ¦   «         ¦  «        dk    rt          d¦  «        ‚t	          | dg¦  «        }t	          | dg¦  «        }t          ||¬¦  «        t          ||¬¦  «        z   t          | |¬¦  «        z
  S )a¯  Calculate the mutual information of a bipartite state.

    The mutual information :math:`I` is given by:

    .. math::

        I(\rho_{AB}) = S(\rho_A) + S(\rho_B) - S(\rho_{AB})

    where :math:`\rho_A=Tr_B[\rho_{AB}], \rho_B=Tr_A[\rho_{AB}]`, are the
    reduced density matrices of the bipartite state :math:`\rho_{AB}`.

    Args:
        state (Statevector or DensityMatrix): a bipartite state.
        base (int): the base of the logarithm [Default: 2].

    Returns:
        float: The mutual information :math:`I(\rho_{AB})`.

    Raises:
        QiskitError: if the input state is not a valid QuantumState.
        QiskitError: if input is not a bipartite QuantumState.
    Tr   r   z(Input must be a bipartite quantum state.é   r   r0   )r	   ÚlenÚdimsr   r   r6   )r)   r,   Úrho_aÚrho_bs       r&   Úmutual_informationr=   †   sš   € õ. ˜%¨$Ð/Ñ/Ô/€EÝ
ˆ5�:Š:‰<Œ<ÑÔ˜AÒÐÝÐDÑEÔEÐEÝ˜% ! Ñ%Ô%€EÝ˜% ! Ñ%Ô%€EÝ�5˜tÐ$Ñ$Ô$¥w¨u¸4Ð'@Ñ'@Ô'@Ñ@Å7È5ÐW[ÐC\ÑC\ÔC\Ñ\Ð\r(   c                ó  — ddl m} t          | d¬¦  «        } t          | t          ¦  «        r¤|                      ¦   «         }t          |¦  «        dk    rt          d¦  «        ‚|d         |d         k    rdgndg}t          | |¦  «        }t          t          j        ddt          j        t          |¦  «        ¦  «        z
  z  ¦  «        ¦  «        S | j        dk    rt          d	¦  «        ‚t          | ¦  «        j        }t          j        t          j        g d
¢¦  «        ¦  «        }|                     |¦  «                             |                     ¦   «         ¦  «                             |¦  «        }t          j        t          j        |                     |¦  «        ¦  «        ¦  «        }t          j        t          j        |d¦  «        ¦  «        }t1          d|d         t          j        |dd…         ¦  «        z
  ¦  «        S )az  Calculate the concurrence of a quantum state.

    The concurrence of a bipartite
    :class:`~qiskit.quantum_info.Statevector` :math:`|\psi\rangle` is
    given by

    .. math::

        C(|\psi\rangle) = \sqrt{2(1 - Tr[\rho_0^2])}

    where :math:`\rho_0 = Tr_1[|\psi\rangle\!\langle\psi|]` is the
    reduced state from by taking the
    :func:`~qiskit.quantum_info.partial_trace` of the input state.

    For density matrices the concurrence is only defined for
    2-qubit states, it is given by:

    .. math::

        C(\rho) = \max(0, \lambda_1 - \lambda_2 - \lambda_3 - \lambda_4)

    where  :math:`\lambda _1 \ge \lambda _2 \ge \lambda _3 \ge \lambda _4`
    are the ordered eigenvalues of the matrix
    :math:`R=\sqrt{\sqrt{\rho }(Y\otimes Y)\overline{\rho}(Y\otimes Y)\sqrt{\rho}}`.

    Args:
        state (Statevector or DensityMatrix): a 2-qubit quantum state.

    Returns:
        float: The concurrence.

    Raises:
        QiskitError: if the input state is not a valid QuantumState.
        QiskitError: if input is not a bipartite QuantumState.
        QiskitError: if density matrix input is not a 2-qubit state.
    r   NTr   r   ú'Input is not a bipartite quantum state.r8   é   ú-Input density matrix must be a 2-qubit state.)éÿÿÿÿr8   r8   rB   r/   rB   )r1   r   r	   r   r   r:   r9   r   r   r   r   r   r    r+   Údimr   r   ÚfliplrÚdiagr   r   Úsortr3   r2   ÚmaxÚsum)r)   r4   r:   ÚqargsÚrhoÚyy_matÚsigmaÚws           r&   ÚconcurrencerN   ¥   s«  € ðJ ÐÐÐÐÐõ ˜%¨$Ð/Ñ/Ô/€EÝ�%�Ñ%Ô%ð >à�zŠz‰|Œ|ˆÝˆt‰9Œ9˜Š>ˆ>ÝÐGÑHÔHÐHØ˜A”w  a¤Ò(Ð(���¨q¨cˆÝ˜E 5Ñ)Ô)ˆÝ•R”W˜Q !¥b¤g­f°S©k¬kÑ&:Ô&:Ñ":Ñ;Ñ<Ô<Ñ=Ô=Ð=à„y�A‚~€~ÝÐIÑJÔJÐJÝ
˜Ñ
Ô
Ô
#€CÝŒY•r”w˜~˜~˜~Ñ.Ô.Ñ/Ô/€FØ�GŠG�F‰OŒO×Ò §¢¡
¤
Ñ+Ô+×/Ò/°Ñ7Ô7€EÝ
Œ•”˜Ÿ
š
 5Ñ)Ô)Ñ*Ô*Ñ+Ô+€AÝ
Œ•”
˜1˜cÑ"Ô"Ñ#Ô#€AÝˆs�A�b”E�BœF 1 Q r T¤7™OœOÑ+Ñ,Ô,Ð,r(   c                óâ  — t          | d¬¦  «        } t          | t          ¦  «        rm|                      ¦   «         }t	          |¦  «        dk    rt          d¦  «        ‚|d         |d         k    rdgndg}t          t          | |¦  «        d¬¦  «        S | j        dk    rt          d	¦  «        ‚t          | ¦  «        }dt          j        d|dz  z
  ¦  «        z   dz  }t          |d|z
  g¦  «        S )
a	  Calculate the entanglement of formation of quantum state.

    The input quantum state must be either a bipartite state vector, or a
    2-qubit density matrix.

    Args:
        state (Statevector or DensityMatrix): a 2-qubit quantum state.

    Returns:
        float: The entanglement of formation.

    Raises:
        QiskitError: if the input state is not a valid QuantumState.
        QiskitError: if input is not a bipartite QuantumState.
        QiskitError: if density matrix input is not a 2-qubit state.
    Tr   r   r?   r   r8   r0   r@   rA   )r	   r   r   r:   r9   r   r6   r   rC   rN   r   r   r   )r)   r:   rI   ÚconcÚvals        r&   Úentanglement_of_formationrR   á   sñ   € õ" ˜%¨$Ð/Ñ/Ô/€EÝ�%�Ñ%Ô%ð <ð �zŠz‰|Œ|ˆÝˆt‰9Œ9˜Š>ˆ>ÝÐGÑHÔHÐHØ˜A”w  a¤Ò(Ð(���¨q¨cˆÝ•} U¨EÑ2Ô2¸Ð;Ñ;Ô;Ð;ð „y�A‚~€~ÝÐIÑJÔJÐJÝ�uÑÔ€DØ�rŒw�q˜D !™G‘}Ñ%Ô%Ñ%¨Ñ
*€CÝ˜C  S¡˜>Ñ*Ô*Ð*r(   c                óü   — t          | t          ¦  «        rt          | ¦  «        } |                      |¦  «        } t          j                             | j        d¬¦  «        }t	          j        |¦  «        }|dz
  dz  }|S )a¿  Calculates the negativity

    The mathematical expression for negativity is given by:
    .. math::
        {\cal{N}}(\rho) = \frac{|| \rho^{T_A}|| - 1 }{2}

    Args:
        state (Statevector or DensityMatrix): a quantum state.
        qargs (list): The subsystems to be transposed.

    Returns:
        negv (float): Negativity value of the quantum state

    Raises:
        QiskitError: if the input state is not a valid QuantumState.
    F)Ú
compute_uvr8   r   )	r   r   r   Úpartial_transposer   r   Úsvdr   rH   )r)   rI   Úsingular_valuesr3   Únegvs        r&   Ú
negativityrY     sq   € õ$ �%�Ñ%Ô%ð %å˜eÑ$Ô$ˆà×#Ò# EÑ*Ô*€Eå”i—m’m E¤J¸5�mÑAÔA€OÝŒf�_Ñ%Ô%€Gà�a‰K˜1Ñ€DØ€Kr(   )T)r   r   r   r   r   r   r   r   )r)   r   r   r   r   r   )r   )r)   r   r,   r-   r   r   )r)   r   r   r   )Ú__doc__Ú
__future__r   Únumpyr   Úqiskit.exceptionsr   Ú&qiskit.quantum_info.states.statevectorr   Ú(qiskit.quantum_info.states.densitymatrixr   Ú qiskit.quantum_info.states.utilsr   r   r	   r
   r'   r+   r6   r=   rN   rR   rY   © r(   r&   ú<module>rb      sU  ððð ð #Ð "Ð "Ð "Ð "Ð "Ø Ð Ð Ð Ø )Ð )Ð )Ð )Ð )Ð )Ø >Ð >Ð >Ð >Ð >Ð >Ø BÐ BÐ BÐ BÐ BÐ Bðð ð ð ð ð ð ð ð ð ð ð ð `dð2ð 2ð 2ð 2ð 2ðjð ð ð ð ð.-ð -ð -ð -ð -ð:]ð ]ð ]ð ]ð ]ð>9-ð 9-ð 9-ð 9-ðx +ð  +ð  +ð  +ðFð ð ð ð r(   