
    z	iY(                    F   S r SSKJr  SSKJr  SSKrSSKJr  SSK	J
r
  SSKJr  SSKJrJrJrJrJrJrJrJrJrJrJr  SS	KJr  SS
KJr  SSKJr  SSKJ r   \(       a  SSK!J"r"  Sr#S// SQS/SS/SS/S/SS/SS/SS/SS// SQSS/S.r$\\\\\\\\\\\S.r% " S S5      r&g)z4
Decompose a single-qubit unitary via Euler angles.
    )annotations)TYPE_CHECKINGN)euler_one_qubit_decomposer)QuantumCircuit)Qubit)UGate	PhaseGateU3GateU2GateU1GateRXGateRYGateRZGateRGateSXGateXGate)QiskitError)is_unitary_matrix)Gate)Operator)
DAGCircuitg-q=u3)r   u2u1upsxr   rxrrzry)r    r   x)U3U321UPSXU1XRRZYZZXZXZXXYXZSXXZSX)r   r   r   r   r   r   r!   r    r   r   r"   c                  ~   \ rS rSrSrSSS jjrSS jrS\4       SS jjrS\4S jr	\
S 5       r\R                  S	 5       rSS
 jrSS jr\" \R"                  5      r\" \R&                  5      r\" \R*                  5      r\" \R.                  5      r\" \R2                  5      r\" \R6                  5      rSrg)OneQubitEulerDecomposerL   a	  A class for decomposing 1-qubit unitaries into Euler angle rotations.

The resulting decomposition is parameterized by 3 Euler rotation angle
parameters :math:`(\theta, \phi, \lambda)`, and a phase parameter
:math:`\gamma`. The value of the parameters for an input unitary depends
on the decomposition basis. Allowed bases and the resulting circuits are
shown in the following table. Note that for the non-Euler bases (:math:`U3`,
:math:`U1X`, :math:`RR`), the :math:`ZYZ` Euler parameters are used.

.. list-table:: Supported circuit bases
    :widths: auto
    :header-rows: 1

    * - Basis
      - Euler Angle Basis
      - Decomposition Circuit
    * - 'ZYZ'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} R_Z(\phi).R_Y(\theta).R_Z(\lambda)`
    * - 'ZXZ'
      - :math:`Z(\phi) X(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} R_Z(\phi).R_X(\theta).R_Z(\lambda)`
    * - 'XYX'
      - :math:`X(\phi) Y(\theta) X(\lambda)`
      - :math:`e^{i\gamma} R_X(\phi).R_Y(\theta).R_X(\lambda)`
    * - 'XZX'
      - :math:`X(\phi) Z(\theta) X(\lambda)`
      - :math:`e^{i\gamma} R_X(\phi).R_Z(\theta).R_X(\lambda)`
    * - 'U3'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} U_3(\theta,\phi,\lambda)`
    * - 'U321'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} U_3(\theta,\phi,\lambda)`
    * - 'U'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} U_3(\theta,\phi,\lambda)`
    * - 'PSX'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} U_1(\phi+\pi).R_X\left(\frac{\pi}{2}\right).`
        :math:`U_1(\theta+\pi).R_X\left(\frac{\pi}{2}\right).U_1(\lambda)`
    * - 'ZSX'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} R_Z(\phi+\pi).\sqrt{X}.`
        :math:`R_Z(\theta+\pi).\sqrt{X}.R_Z(\lambda)`
    * - 'ZSXX'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} R_Z(\phi+\pi).\sqrt{X}.R_Z(\theta+\pi).\sqrt{X}.R_Z(\lambda)`
        or
        :math:`e^{i\gamma} R_Z(\phi+\pi).X.R_Z(\lambda)`
    * - 'U1X'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} U_1(\phi+\pi).R_X\left(\frac{\pi}{2}\right).`
        :math:`U_1(\theta+\pi).R_X\left(\frac{\pi}{2}\right).U_1(\lambda)`
    * - 'RR'
      - :math:`Z(\phi) Y(\theta) Z(\lambda)`
      - :math:`e^{i\gamma} R\left(-\pi,\frac{\phi-\lambda+\pi}{2}\right).`
        :math:`R\left(\theta+\pi,\frac{\pi}{2}-\lambda\right)`

.. automethod:: __call__
c                    Xl         X l        g)a  Initialize decomposer

Supported bases are: ``'U'``, ``'PSX'``, ``'ZSXX'``, ``'ZSX'``, ``'U321'``, ``'U3'``,
``'U1X'``, ``'RR'``, ``'ZYZ'``, ``'ZXZ'``, ``'XYX'``, ``'XZX'``.

Args:
    basis: the decomposition basis [Default: ``'U3'``]
    use_dag: If true the output from calls to the decomposer
        will be a :class:`~qiskit.dagcircuit.DAGCircuit` object instead of
        :class:`~qiskit.circuit.QuantumCircuit`.

Raises:
    QiskitError: If input basis is not recognized.
N)basisuse_dag)selfr3   r4   s      h/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/synthesis/one_qubit/one_qubit_decompose.py__init__ OneQubitEulerDecomposer.__init__   s     
    c                f   [        5       /nSn[        U5      S:  a  [        US   [        5      (       a  SnSSKJn  UR                  5       nX&l        UR                  U5        U HG  nU(       a  [        US   R                     " US   6 nOUR                  nUR                  XS   4SS9  MI     U$ )z6Return the circuit or dag object from a list of gates.Fr   T)
dagcircuit   )check)r   len
isinstancetupleqiskit.dagcircuitr;   r   global_phase
add_qubitsNAME_MAPnameapply_operation_back)	r5   gatesrB   qrlookup_gater;   dag
gate_entrygates	            r6   build_circuit%OneQubitEulerDecomposer.build_circuit   s    gYu:>jq599K0##%'rJ
1 2 23Z]C!$$TqE85$A   
r9   Tc                Z   [        US5      (       a  UR                  5       R                  nO![        US5      (       a  UR                  5       n[        R
                  " U[        S9nUR                  S:w  a  [        S5      e[        U5      (       d  [        S5      eU R                  XUS9$ )a  Decompose single qubit gate into a circuit.

Args:
    unitary: 1-qubit unitary matrix
    simplify: reduce gate count in decomposition [Default: True].
    atol: absolute tolerance for checking angles when simplifying
                 returned circuit [Default: 1e-12].

Returns:
    QuantumCircuit: the decomposed single-qubit gate circuit

Raises:
    QiskitError: if input is invalid or synthesis fails.
to_operator	to_matrixdtype)   rT   z2OneQubitEulerDecomposer: expected 2x2 input matrixz5OneQubitEulerDecomposer: input matrix is not unitary.)simplifyatol)hasattrrP   datarQ   npasarraycomplexshaper   r   
_decompose)r5   unitaryrU   rV   s       r6   __call__ OneQubitEulerDecomposer.__call__   s    ( 7M** ))+00GWk** '')G**WG4 ==F"RSS ))UVVwEEr9   c           
        U R                   (       aA  [        R                  " XR                  /SS X#5      nU R	                  XDR
                  5      nU$ [        R                  " [        R                  " XR                  /SS X#5      SS9$ )Nr   T)legacy_qubits)	r4   r   unitary_to_gate_sequencer3   rM   rB   r   _from_circuit_dataunitary_to_circuit)r5   r^   rU   rV   circuit_sequencecircuits         r6   r]   "OneQubitEulerDecomposer._decompose   s|    <<9RR**q$  (()9;X;XYGN00&99**q$ 	
 	
r9   c                    U R                   $ )zThe decomposition basis.)_basis)r5   s    r6   r3   OneQubitEulerDecomposer.basis   s     {{r9   c                V   U R                   U R                   U R                   U R                  U R                  U R                  U R                  U R                  U R                  U R                  U R                  U R
                  S.nX;  a  [        SU 35      eXl        X!   U l        g)zSet the decomposition basis.)r$   r#   r%   r&   r.   r-   r'   r(   r)   r*   r,   r+   z+OneQubitEulerDecomposer: unsupported basis N)	
_params_u3_params_u1x_params_zyz_params_zxz_params_xyx_params_xzxr   rj   _params)r5   r3   basis_methodss      r6   r3   rk      s     OO//####$$##""########
 % KE7STT$+r9   c                d    [         R                  " U[        S9nU R                  U5      u  p#pEX#U4$ )zReturn the Euler angles for input array.

Args:
    unitary: :math:`2\times2` unitary matrix.

Returns:
    tuple: ``(theta, phi, lambda)``.
rR   rY   rZ   r[   rs   )r5   r^   thetaphilam_s         r6   anglesOneQubitEulerDecomposer.angles  s1     **WG4!\\'2C3r9   c                V    [         R                  " U[        S9nU R                  U5      $ )zReturn the Euler angles and phase for input array.

Args:
    unitary: :math:`2\times2`

Returns:
    tuple: ``(theta, phi, lambda, phase)``.
rR   rv   )r5   r^   s     r6   angles_and_phase(OneQubitEulerDecomposer.angles_and_phase  s#     **WG4||G$$r9   )rj   rs   r3   r4   N)r#   F)r3   strr4   bool)returnQuantumCircuit | DAGCircuit)r^   zOperator | Gate | np.ndarrayrU   r   rV   floatr   r   )r^   z
np.ndarrayr   r@   )__name__
__module____qualname____firstlineno____doc__r7   rM   DEFAULT_ATOLr_   r]   propertyr3   setterr{   r~   staticmethodr   
params_zyzro   
params_zxzrp   
params_xyxrq   
params_xzxrr   	params_u3rm   
params_u1xrn   __static_attributes__ r9   r6   r0   r0   L   s    <|$0 "	%F-%F %F 	%F
 
%%FN ,0l 
   \\, ,*
% 9DDEK9DDEK9DDEK9DDEK8BBCJ9DDEKr9   r0   )'r   
__future__r   typingr   numpyrY   qiskit._accelerater   qiskit.circuit.quantumcircuitr   qiskit.circuitr   %qiskit.circuit.library.standard_gatesr   r	   r
   r   r   r   r   r   r   r   r   qiskit.exceptionsr   (qiskit.quantum_info.operators.predicatesr   qiskit.circuit.gater   &qiskit.quantum_info.operators.operatorr   rA   r   r   ONE_QUBIT_EULER_BASIS_GATESrD   r0   r   r9   r6   <module>r      s    #    9 8      * F $ ;, &
;$<%$<$<$<$<$<   



	


	
	TF TFr9   