z i0SrSSKJr SSKrSSKJr SSKJr SSK J r SSK J r SSK Jr SS KJr S S KJr "S S \5r"SS\5rg)a} ======================================================================================================= Solovay-Kitaev Synthesis Plugin (in :mod:`qiskit.transpiler.passes.synthesis.solovay_kitaev_synthesis`) ======================================================================================================= .. autosummary:: :toctree: ../stubs/ SolovayKitaevSynthesis ) annotationsN)circuit_to_dag)Gate) DAGCircuit)SolovayKitaevDecomposition)TransformationPass)trivial_recurse)UnitarySynthesisPluginch^\rSrSrSrS SSS.S U4Sjjjjr\S Sj5rSrU=r $) SolovayKitaev&u& Approximately decompose 1q gates to a discrete basis using the Solovay-Kitaev algorithm. The Solovay-Kitaev theorem [1] states that any single qubit gate can be approximated to arbitrary precision by a set of fixed single-qubit gates, if the set generates a dense subset in :math:`SU(2)`. This is an important result, since it means that any single-qubit gate can be expressed in terms of a discrete, universal gate set that we know how to implement fault-tolerantly. Therefore, the Solovay-Kitaev algorithm allows us to take any non-fault tolerant circuit and rephrase it in a fault-tolerant manner. This implementation of the Solovay-Kitaev algorithm is based on [2]. For example, the following circuit .. code-block:: text ┌─────────┐ q_0: ┤ RX(0.8) ├ └─────────┘ can be decomposed into .. code-block:: text global phase: 7π/8 ┌───┐┌───┐┌───┐ q_0: ┤ H ├┤ T ├┤ H ├ └───┘└───┘└───┘ with an L2-error of approximately 0.01. Examples: Per default, the basis gate set is ``["t", "tdg", "h"]``: .. plot:: :include-source: :nofigs: import numpy as np from qiskit.circuit import QuantumCircuit from qiskit.transpiler.passes.synthesis import SolovayKitaev from qiskit.quantum_info import Operator circuit = QuantumCircuit(1) circuit.rx(0.8, 0) print("Original circuit:") print(circuit.draw()) skd = SolovayKitaev(recursion_degree=2) discretized = skd(circuit) print("Discretized circuit:") print(discretized.draw()) print("Error:", np.linalg.norm(Operator(circuit).data - Operator(discretized).data)) .. code-block:: text Original circuit: ┌─────────┐ q: ┤ Rx(0.8) ├ └─────────┘ Discretized circuit: global phase: 7π/8 ┌───┐┌───┐┌───┐ q: ┤ H ├┤ T ├┤ H ├ └───┘└───┘└───┘ Error: 2.828408279166474 For individual basis gate sets, the ``generate_basic_approximations`` function can be used: .. plot:: :include-source: :nofigs: from qiskit.synthesis import generate_basic_approximations from qiskit.transpiler.passes import SolovayKitaev basis = ["s", "sdg", "t", "tdg", "z", "h"] approx = generate_basic_approximations(basis, depth=3) skd = SolovayKitaev(recursion_degree=2, basic_approximations=approx) References: [1]: Kitaev, A Yu (1997). Quantum computations: algorithms and error correction. Russian Mathematical Surveys. 52 (6): 1191–1249. `Online `_. [2]: Dawson, Christopher M.; Nielsen, Michael A. (2005) The Solovay-Kitaev Algorithm. `arXiv:quant-ph/0505030 `_. N  basis_gatesdepthcL>[TU]5 Xl[X#US9Ulg)a  Args: recursion_degree: The recursion depth for the Solovay-Kitaev algorithm. A larger recursion depth increases the accuracy and length of the decomposition. basic_approximations: The basic approximations for the finding the best discrete decomposition at the root of the recursion. If a string, it specifies the file to load the approximations from. If a dictionary, it contains ``{label: SO(3)-matrix}`` pairs. If ``None``, a default based on the :math:`H`, :math:`T` and :math:`T^\dagger` gates up to depth 16 is generated. Note that if ``basic_approximations`` is passed, ``basis_gates`` and ``depth`` cannot be set. basis_gates: The basis gates used to build the net of basic approximations. Defaults to ``["h", "t", "tdg"]``. This argument cannot be set if ``basic_approximations`` is provided. depth: The maximal gate depth used in basic approximations. This argument cannot be set if ``basic_approximations`` is provided. rN)super__init__recursion_degreer_sk)selfrbasic_approximationsrr __class__s u/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/transpiler/passes/synthesis/solovay_kitaev_synthesis.pyrSolovayKitaev.__init__s'4  0-  cUR5HnURRS:wd0UR5(d[ URS5(dMO[ UR[ 5(+nURRURURSUS9nURX$5 M U$)zRun the ``SolovayKitaev`` pass on `dag`. Args: dag: The input dag. Returns: Output dag with 1q gates synthesized in the discrete target basis. Raises: TranspilerError: if a gates does not have to_matrix r to_matrixT) return_dag check_input) op_nodesop num_qubitsis_parameterizedhasattr isinstancerrrunrsubstitute_node_with_dag)rdagnoder! approximations rr(SolovayKitaev.runsLLND##q(((**55)$77K!HHLL..4[)M  ( ( ='#* r)rr)N) rintrz"str | dict[str, np.ndarray] | Nonerzlist[str | Gate] | Nonerr/returnNone)r*rr0r) __name__ __module__ __qualname____firstlineno____doc__rr r(__static_attributes__ __classcell__)rs@rr r &so^D!"CG 04   A -       @!!rr c\rSrSrSrSrSrSr\S5r \S5r \S5r \S5r \S5r \S 5r\S 5r\S 5r\S 5rS rSrg)SolovayKitaevSynthesisaA Solovay-Kitaev Qiskit unitary synthesis plugin. This plugin is invoked by :func:`~.compiler.transpile` when the ``unitary_synthesis_method`` parameter is set to ``"sk"``. This plugin supports customization and additional parameters can be passed to the plugin by passing a dictionary as the ``unitary_synthesis_plugin_config`` parameter of the :func:`~qiskit.compiler.transpile` function. Supported parameters in the dictionary: basic_approximations (str | dict): The basic approximations for the finding the best discrete decomposition at the root of the recursion. If a string, it specifies the ``.npy`` file to load the approximations from. If a dictionary, it contains ``{label: SO(3)-matrix}`` pairs. If None, a default based on the specified ``basis_gates`` and ``depth`` is generated. basis_gates (list): A list of strings specifying the discrete basis gates to decompose to. If None, it defaults to ``["h", "t", "tdg"]``. If ``basic_approximations`` is not None, ``basis_set`` is required to correspond to the basis set that was used to generate it. depth (int): The gate-depth of the basic approximations. All possible, unique combinations of the basis gates up to length ``depth`` are considered. If None, defaults to 12. If ``basic_approximations`` is not None, ``depth`` is required to correspond to the depth that was used to generate it. recursion_degree (int): The number of times the decomposition is recursively improved. If None, defaults to 5. Ncg)z,Maximum number of supported qubits is ``1``.r rs r max_qubits!SolovayKitaevSynthesis.max_qubitsrcg)z,Minimum number of supported qubits is ``1``.r r=r>s r min_qubits!SolovayKitaevSynthesis.min_qubitsrArcg)z`The plugin does not support natural direction, it does not assume bidirectional two qubit gates.Tr=r>s rsupports_natural_direction1SolovayKitaevSynthesis.supports_natural_directionrcg)z3The plugin does not support optimization of pulses.Fr=r>s rsupports_pulse_optimize.SolovayKitaevSynthesis.supports_pulse_optimize rcg)z)The plugin does not support gate lengths.Fr=r>s rsupports_gate_lengths,SolovayKitaevSynthesis.supports_gate_lengthsrLrcg)z(The plugin does not support gate errors.Fr=r>s rsupports_gate_errors+SolovayKitaevSynthesis.supports_gate_errorsrLrcg)z0The plugin does not support bases for synthesis.Nr=r>s rsupported_bases&SolovayKitaevSynthesis.supported_basessrcg)ziThe plugin does not support basis gates. By default it synthesis to the ``["h", "t", "tdg"]`` gate basis.Tr=r>s rsupports_basis_gates+SolovayKitaevSynthesis.supports_basis_gatesrHrcg)z*The plugin does not support coupling maps.Fr=r>s rsupports_coupling_map,SolovayKitaevSynthesis.supports_coupling_map$rLrc URS5=(d 0nURSS5nURSS5nURSS5nURSS5n[Rb(U[R:wdU[R:wa)U[lU[l[ XdUS 9[l[RR X5n[U5$) zERun the SolovayKitaevSynthesis synthesis plugin on the given unitary.configrNrrrrr.r)getr:r _basis_gates_depthrr(r) runitaryoptionsr]rrrrapproximate_circuits rr(SolovayKitaevSynthesis.run)sX&,"kk-6  7B'%zz*@$G!::&8!< # & & . 2?? ?/6662= " /,1 " ))C$U* " &588<rpsF #,$(U;G*c&cLr33r3r