gp"pdZddlmZddlZddlmZddlmZddlm Z m Z m Z Gdd Z d Z d ZdS) z7Synthesize a single qubit gate to a discrete basis set.) annotationsN) GateSequence)commutator_decompose)generate_basic_approximations _1q_gates _1q_inversescVeZdZdZ dddZedd Z dd dZd!d"dZd#dZ dS)$SolovayKitaevDecompositionzThe Solovay Kitaev discrete decomposition algorithm. This class is called recursively by the transpiler pass, which is why it is separeted. See :class:`qiskit.transpiler.passes.SolovayKitaev` for more information. Nbasic_approximations7str | dict[str, np.ndarray] | list[GateSequence] | NonereturnNonecd|tgdd}|||_dS)a Args: basic_approximations: A specification of the basic SU(2) approximations in terms of discrete gates. At each iteration this algorithm, the remaining error is approximated with the closest sequence of gates in this set. If a ``str``, this specifies a ``.npy`` filename from which to load the approximation. If a ``dict``, then this contains ``{gates: effective_SO3_matrix}`` pairs, e.g. ``{"h t": np.array([[0, 0.7071, -0.7071], [0, -0.7071, -0.7071], [-1, 0, 0]]}``. If a list, this contains the same information as the dict, but already converted to :class:`.GateSequence` objects, which contain the SO(3) matrix and gates. N)httdg ) basis_gatesdepth)rload_basic_approximationsr )selfr s d/granary/edev/quantum/lib/python3.11/site-packages/qiskit/synthesis/discrete_basis/solovay_kitaev.py__init__z#SolovayKitaevDecomposition.__init__sI '#@---R$$$ %)$B$BCW$X$X!!!datalist | str | dictlist[GateSequence]ct|tr|St|tr(tj|d}g}|D]\}}t|tr|\}}n|d}}t}d| D|_ d|j D|_ tj ||_ ||_|||S)aLoad basic approximations. Args: data: If a string, specifies the path to the file from where to load the data. If a dictionary, directly specifies the decompositions as ``{gates: matrix}`` or ``{gates: (matrix, global_phase)}``. There, ``gates`` are the names of the gates producing the SO(3) matrix ``matrix``, e.g. ``{"h t": np.array([[0, 0.7071, -0.7071], [0, -0.7071, -0.7071], [-1, 0, 0]]}`` and the ``global_phase`` can be given to account for a global phase difference between the U(2) matrix of the quantum gates and the stored SO(3) matrix. If not given, the ``global_phase`` will be assumed to be 0. Returns: A list of basic approximations as type ``GateSequence``. Raises: ValueError: If the number of gate combinations and associated matrices does not match. T) allow_picklerc(g|]}t|S)r).0elements r zHSolovayKitaevDecomposition.load_basic_approximations..ZsSSSWi0SSSrcg|] }|j Sr")name)r#gates rr%zHSolovayKitaevDecomposition.load_basic_approximations..[sDDDTtyDDDr) isinstanceliststrnploaditemitemstuplersplitgateslabelsasarrayproduct global_phaseappend)r sequences gatestringmatrix_and_phasematrixr6sequences rrz4SolovayKitaevDecomposition.load_basic_approximations6s* dD ! ! K dC  ;74d33388::D ,0JJLL ' ' (J(*E22 ;'7$ '7 #~~HSS @P@P@R@RSSSHNDDX^DDDHO!z&11H $0H !   X & & & &rFT gate_matrix np.ndarrayrecursion_degreeint return_dagbool check_input'QuantumCircuit' | 'DAGCircuit'cdtjtj|z }t j||z}tjtj|tj|}| |||}t|t||r| } n| } |j|z | _| S)a6Run the algorithm. Args: gate_matrix: The 2x2 matrix representing the gate. This matrix has to be SU(2) up to global phase. recursion_degree: The recursion degree, called :math:`n` in the paper. return_dag: If ``True`` return a :class:`.DAGCircuit`, else a :class:`.QuantumCircuit`. check_input: If ``True`` check that the input matrix is valid for the decomposition. Returns: A one-qubit circuit approximating the ``gate_matrix`` in the specified discrete basis. rrC)r,sqrtlinalgdetr from_matrixarctan2imagreal_recurse_remove_identities_remove_inverse_follows_gateto_dag to_circuitr6) rr=r?rArCzgate_matrix_su2r6 decompositionouts rrunzSolovayKitaevDecomposition.runbs(  k2233 3&21{?CCz"'!**bgajj99  o7GU` aa  =)))$]333  -&&((CC**,,C(5 D rr<rnc|jjdkrtd|j|dkr||S|||dz |}t ||j|\}}|||dz |}|||dz |}|||||S)aOPerforms ``n`` iterations of the Solovay-Kitaev algorithm on ``sequence``. Args: sequence: ``GateSequence`` to which the Solovay-Kitaev algorithm is applied. n: The number of iterations that the algorithm needs to run. check_input: If ``True`` check that the input matrix represented by ``GateSequence`` is valid for the decomposition. Returns: GateSequence that approximates ``sequence``. Raises: ValueError: If the matrix in ``GateSequence`` does not represent an SO(3)-matrix. )rZz Shape of U must be (3, 3) but isrrrF)r5shape ValueErrorfind_basic_approximationrNrdotadjoint) rr<rXrCu_n1v_nw_nv_n1w_n1s rrNz#SolovayKitaevDecomposition._recurses   !V + +?PP P 6600:: :}}Xq1u+}FF' LL ( ( 0k   S}}S!a%[}AA}}S!a%[}AAxx~~!!$,,..1155dllnnEEII$OOOrc>fd}t|j|}|S)a%Find ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``. Args: sequence: ``GateSequence`` to find the approximation to. Returns: ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``. c|tjtj|jjSN)r,rHnormsubtractr5)xr<s rkeyz@SolovayKitaevDecomposition.find_basic_approximation..keys(9>>"+ai9I"J"JKK Kr)rk)minr )rr<rkbests ` rr]z3SolovayKitaevDecomposition.find_basic_approximations= L L L L L4,#666 rrg)r r rr)rrrr)FT) r=r>r?r@rArBrCrBrrD)T)r<rrXr@rCrBrr)r<rrr) __name__ __module__ __qualname____doc__r staticmethodrrWrNr]r"rrr r s_cYYYYY.)))\)^! '''''RPPPPP>rr cd}|t|jdz kr|j|}|j|dz}|jtvrt|j|jk}n||k}|r&|||dzg|dkr|dz}n|dz }|t|jdz kdSdS)Nrr)lenr2r'r inverseremove_cancelling_pair)r<index curr_gate next_gateremoves rrPrPs E #hn%%) ) )N5) N519- >\ ) )!).1Y^CFF&&((I5F    + +UEAI,> ? ? ?qyy  QJE% #hn%%) ) ) ) ) ) )rcd}|t|jkrP|j|jdkr|j|n|dz }|t|jkNdSdS)Nridr)rtr2r'pop)r<rws rrOrOsv E #hn%% % % >% % - - N  u % % % % QJE #hn%% % % % % % %r)rq __future__rnumpyr, gate_sequencerrgenerate_basis_approximationsrrr r rPrOr"rrrs>=""""""''''''666666aaaaaaaaaaaaaaaaaaH.r