z izy~SrSSKJr SSKrSSKrSSKrSSKJ r SSK J r SSK J r JrJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJrJrJrJ r J!r!J"r" SSK#J$r$ SS K%J&r&J'r'J(r( SS K)J*r*J+r+J,r,J-r-J.r.J/r/ SS K0J1r1J2r2J3r3 SS K4J5r5 SS K6J7r7J8r8J9r9 SSK:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrI SSKJJKrKJLrL SSK%JMrMJNrNJOrOJPrPJQrQJRrRJSrS SSKTJUrU SSKVJWrW SSKXJYrY SSKZJ[r[ SSK\J]r] SSK^J_r_J`r` SSKaJbrb "SS\b5rc"SS\b5rd"SS\b5re"S S!\b5rf"S"S#\b5rg"S$S%\b5rh"S&S'\b5ri"S(S)\b5rj"S*S+\b5rk"S,S-\b5rl"S.S/\b5rm"S0S1\b5rn"S2S3\b5ro"S4S5\b5rp"S6S7\b5rq"S8S9\b5rr"S:S;\b5rs"S<S=\b5rt"S>S?\b5ru"S@SA\b5rv"SBSC\b5rw"SDSE\b5rx"SFSG\b5ry"SHSI\b5rz"SJSK\b5r{"SLSM\b5r|"SNSO\b5r}"SPSQ\b5r~"SRSS\b5r"STSU\b5r"SVSW\b5r"SXSY\b5r"SZS[\b5r"S\S]\b5r"S^S_\b5r"S`Sa\b5r"SbSc\b5r"SdSe\b5r"SfSg\b5r"ShSi\b5r"SjSk\b5r"SlSm\b5r"SnSo\b5r"SpSq\b5r"SrSs\b5r"StSu\b5r"SvSw\b5r"SxSy\b5r"SzS{\b5r"S|S}\b5r"S~S\b5r"SS\b5r"SS\b5rg)a0 High Level Synthesis Plugins ----------------------------- Clifford Synthesis '''''''''''''''''' .. list-table:: Plugins for :class:`qiskit.quantum_info.Clifford` (key = ``"clifford"``) :header-rows: 1 * - Plugin name - Plugin class - Targeted connectivity - Description * - ``"ag"`` - :class:`~.AGSynthesisClifford` - all-to-all - greedily optimizes CX-count * - ``"bm"`` - :class:`~.BMSynthesisClifford` - all-to-all - optimal count for `n=2,3`; used in ``"default"`` for `n=2,3` * - ``"greedy"`` - :class:`~.GreedySynthesisClifford` - all-to-all - greedily optimizes CX-count; used in ``"default"`` for `n>=4` * - ``"layers"`` - :class:`~.LayerSynthesisClifford` - all-to-all - * - ``"lnn"`` - :class:`~.LayerLnnSynthesisClifford` - linear - many CX-gates but guarantees CX-depth of at most `7*n+2` * - ``"default"`` - :class:`~.DefaultSynthesisClifford` - all-to-all - usually best for optimizing CX-count (and optimal CX-count for `n=2,3`) .. autosummary:: :toctree: ../stubs/ AGSynthesisClifford BMSynthesisClifford GreedySynthesisClifford LayerSynthesisClifford LayerLnnSynthesisClifford DefaultSynthesisClifford Linear Function Synthesis ''''''''''''''''''''''''' .. list-table:: Plugins for :class:`.LinearFunction` (key = ``"linear"``) :header-rows: 1 * - Plugin name - Plugin class - Targeted connectivity - Description * - ``"kms"`` - :class:`~.KMSSynthesisLinearFunction` - linear - many CX-gates but guarantees CX-depth of at most `5*n` * - ``"pmh"`` - :class:`~.PMHSynthesisLinearFunction` - all-to-all - greedily optimizes CX-count; used in ``"default"`` * - ``"default"`` - :class:`~.DefaultSynthesisLinearFunction` - all-to-all - best for optimizing CX-count .. autosummary:: :toctree: ../stubs/ KMSSynthesisLinearFunction PMHSynthesisLinearFunction DefaultSynthesisLinearFunction Permutation Synthesis ''''''''''''''''''''' .. list-table:: Plugins for :class:`.PermutationGate` (key = ``"permutation"``) :header-rows: 1 * - Plugin name - Plugin class - Targeted connectivity - Description * - ``"basic"`` - :class:`~.BasicSynthesisPermutation` - all-to-all - optimal SWAP-count; used in ``"default"`` * - ``"acg"`` - :class:`~.ACGSynthesisPermutation` - all-to-all - guarantees SWAP-depth of at most `2` * - ``"kms"`` - :class:`~.KMSSynthesisPermutation` - linear - many SWAP-gates, but guarantees SWAP-depth of at most `n` * - ``"token_swapper"`` - :class:`~.TokenSwapperSynthesisPermutation` - any - greedily optimizes SWAP-count for arbitrary connectivity * - ``"default"`` - :class:`~.BasicSynthesisPermutation` - all-to-all - best for optimizing SWAP-count .. autosummary:: :toctree: ../stubs/ BasicSynthesisPermutation ACGSynthesisPermutation KMSSynthesisPermutation TokenSwapperSynthesisPermutation QFT Synthesis ''''''''''''' .. list-table:: Plugins for :class:`.QFTGate` (key = ``"qft"``) :header-rows: 1 * - Plugin name - Plugin class - Targeted connectivity * - ``"full"`` - :class:`~.QFTSynthesisFull` - all-to-all * - ``"line"`` - :class:`~.QFTSynthesisLine` - linear * - ``"default"`` - :class:`~.QFTSynthesisFull` - all-to-all .. autosummary:: :toctree: ../stubs/ QFTSynthesisFull QFTSynthesisLine MCX Synthesis ''''''''''''' The following table lists synthesis plugins available for an :class:`.MCXGate` gate with `k` control qubits. If the available number of clean/dirty auxiliary qubits is not sufficient, the corresponding synthesis method will return `None`. .. list-table:: Plugins for :class:`.MCXGate` (key = ``"mcx"``) :header-rows: 1 * - Plugin name - Plugin class - Number of clean ancillas - Number of dirty ancillas - Description * - ``"gray_code"`` - :class:`~.MCXSynthesisGrayCode` - `0` - `0` - exponentially many CX gates; use only for small values of `k` * - ``"noaux_v24"`` - :class:`~.MCXSynthesisNoAuxV24` - `0` - `0` - quadratic number of CX gates * - ``"noaux_hp24"`` - :class:`~.MCXSynthesisNoAuxHP24` - `0` - `0` - linear number of CX gates; use instead of ``"noaux_v24"`` or ``"gray_code"`` for `k>5` * - ``"n_clean_m15"`` - :class:`~.MCXSynthesisNCleanM15` - `k-2` - `0` - at most `6*k-6` CX gates * - ``"n_dirty_i15"`` - :class:`~.MCXSynthesisNDirtyI15` - `0` - `k-2` - at most `8*k-6` CX gates * - ``"2_clean_kg24"`` - :class:`~.MCXSynthesis2CleanKG24` - `2` - `0` - at most `6*k-6` CX gates * - ``"2_dirty_kg24"`` - :class:`~.MCXSynthesis2DirtyKG24` - `0` - `2` - at most `12*k-18` CX gates * - ``"1_clean_kg24"`` - :class:`~.MCXSynthesis1CleanKG24` - `1` - `0` - at most `6*k-6` CX gates * - ``"1_dirty_kg24"`` - :class:`~.MCXSynthesis1DirtyKG24` - `0` - `1` - at most `12*k-18` CX gates * - ``"1_clean_b95"`` - :class:`~.MCXSynthesis1CleanB95` - `1` - `0` - at most `16*k-8` CX gates * - ``"default"`` - :class:`~.MCXSynthesisDefault` - any - any - chooses the best algorithm based on the ancillas available .. autosummary:: :toctree: ../stubs/ MCXSynthesisGrayCode MCXSynthesisNoAuxV24 MCXSynthesisNoAuxHP24 MCXSynthesisNCleanM15 MCXSynthesisNDirtyI15 MCXSynthesis2CleanKG24 MCXSynthesis2DirtyKG24 MCXSynthesis1CleanKG24 MCXSynthesis1DirtyKG24 MCXSynthesis1CleanB95 MCXSynthesisDefault MCMT Synthesis '''''''''''''' .. list-table:: Plugins for :class:`.MCMTGate` (key = ``"mcmt"``) :header-rows: 1 * - Plugin name - Plugin class - Number of clean ancillas - Number of dirty ancillas - Description * - ``"vchain"`` - :class:`.MCMTSynthesisVChain` - `k-1` - `0` - uses a linear number of Toffoli gates * - ``"noaux"`` - :class:`~.MCMTSynthesisNoAux` - `0` - `0` - uses Qiskit's standard control mechanism * - ``"xgate"`` - :class:`.MCMTSynthesisXGate` - `0` - `0` - uses a linear number of Toffoli gates * - ``"default"`` - :class:`~.MCMTSynthesisDefault` - any - any - chooses the best algorithm based on the ancillas available .. autosummary:: :toctree: ../stubs/ MCMTSynthesisVChain MCMTSynthesisNoAux MCMTSynthesisXGate MCMTSynthesisDefault Integer comparators ''''''''''''''''''' .. list-table:: Plugins for :class:`.IntegerComparatorGate` (key = ``"IntComp"``) :header-rows: 1 * - Plugin name - Plugin class - Description - Auxiliary qubits * - ``"twos"`` - :class:`~.IntComparatorSynthesis2s` - use addition with two's complement - ``n - 1`` clean * - ``"noaux"`` - :class:`~.IntComparatorSynthesisNoAux` - flip the target controlled on all :math:`O(2^l)` allowed integer values - none * - ``"default"`` - :class:`~.IntComparatorSynthesisDefault` - use the best algorithm depending on the available auxiliary qubits - any .. autosummary:: :toctree: ../stubs/ IntComparatorSynthesis2s IntComparatorSynthesisNoAux IntComparatorSynthesisDefault Sums '''' .. list-table:: Plugins for :class:`.WeightedSumGate` (key = ``"WeightedSum"``) :header-rows: 1 * - Plugin name - Plugin class - Description - Auxiliary qubits * - ``"default"`` - :class:`.WeightedSumSynthesisDefault` - use a V-chain based synthesis - given ``s`` sum qubits, used ``s - 1 + int(s > 2)`` clean auxiliary qubits .. autosummary:: :toctree: ../stubs/ WeightedSumSynthesisDefault Pauli Evolution Synthesis ''''''''''''''''''''''''' .. list-table:: Plugins for :class:`.PauliEvolutionGate` (key = ``"PauliEvolution"``) :header-rows: 1 * - Plugin name - Plugin class - Description - Targeted connectivity * - ``"rustiq"`` - :class:`~.PauliEvolutionSynthesisRustiq` - use the synthesis method from `Rustiq circuit synthesis library `_ - all-to-all * - ``"default"`` - :class:`~.PauliEvolutionSynthesisDefault` - use a diagonalizing Clifford per Pauli term - all-to-all .. autosummary:: :toctree: ../stubs/ PauliEvolutionSynthesisDefault PauliEvolutionSynthesisRustiq Modular Adder Synthesis ''''''''''''''''''''''' .. list-table:: Plugins for :class:`.ModularAdderGate` (key = ``"ModularAdder"``) :header-rows: 1 * - Plugin name - Plugin class - Number of clean ancillas - Description * - ``"modular_v17"`` - :class:`.ModularAdderSynthesisV17` - 0 - a modular adder without any ancillary qubits * - ``"ripple_cdkm"`` - :class:`.ModularAdderSynthesisC04` - 1 - a ripple-carry adder * - ``"ripple_vbe"`` - :class:`.ModularAdderSynthesisV95` - :math:`n-1`, for :math:`n`-bit numbers - a ripple-carry adder * - ``"qft"`` - :class:`.ModularAdderSynthesisD00` - 0 - a QFT-based adder * - ``"default"`` - :class:`~.ModularAdderSynthesisDefault` - any - chooses the best algorithm based on the ancillas available .. autosummary:: :toctree: ../stubs/ ModularAdderSynthesisV17 ModularAdderSynthesisC04 ModularAdderSynthesisD00 ModularAdderSynthesisV95 ModularAdderSynthesisDefault Half Adder Synthesis '''''''''''''''''''' .. list-table:: Plugins for :class:`.HalfAdderGate` (key = ``"HalfAdder"``) :header-rows: 1 * - Plugin name - Plugin class - Number of clean ancillas - Description * - ``"ripple_cdkm"`` - :class:`.HalfAdderSynthesisC04` - 1 - a ripple-carry adder * - ``"ripple_r25"`` - :class:`.HalfAdderSynthesisR25` - 0 - a ripple-carry adder with no ancillas * - ``"ripple_vbe"`` - :class:`.HalfAdderSynthesisV95` - :math:`n-1`, for :math:`n`-bit numbers - a ripple-carry adder * - ``"qft"`` - :class:`.HalfAdderSynthesisD00` - 0 - a QFT-based adder * - ``"default"`` - :class:`~.HalfAdderSynthesisDefault` - any - chooses the best algorithm based on the ancillas available .. autosummary:: :toctree: ../stubs/ HalfAdderSynthesisC04 HalfAdderSynthesisD00 HalfAdderSynthesisV95 HalfAdderSynthesisR25 HalfAdderSynthesisDefault Full Adder Synthesis '''''''''''''''''''' .. list-table:: Plugins for :class:`.FullAdderGate` (key = ``"FullAdder"``) :header-rows: 1 * - Plugin name - Plugin class - Number of clean ancillas - Description * - ``"ripple_cdkm"`` - :class:`.FullAdderSynthesisC04` - 0 - a ripple-carry adder * - ``"ripple_vbe"`` - :class:`.FullAdderSynthesisV95` - :math:`n-1`, for :math:`n`-bit numbers - a ripple-carry adder * - ``"default"`` - :class:`~.FullAdderSynthesisDefault` - any - chooses the best algorithm based on the ancillas available .. autosummary:: :toctree: ../stubs/ FullAdderSynthesisC04 FullAdderSynthesisV95 FullAdderSynthesisDefault Multiplier Synthesis '''''''''''''''''''' .. list-table:: Plugins for :class:`.MultiplierGate` (key = ``"Multiplier"``) :header-rows: 1 * - Plugin name - Plugin class - Number of clean ancillas - Description * - ``"cumulative"`` - :class:`.MultiplierSynthesisH18` - depending on the :class:`.AdderGate` used - a cumulative adder based on controlled adders * - ``"qft"`` - :class:`.MultiplierSynthesisR17` - 0 - a QFT-based multiplier * - ``"default"`` - :class:`~.MultiplierSynthesisDefault` - any - chooses the best algorithm based on the ancillas available .. autosummary:: :toctree: ../stubs/ MultiplierSynthesisH18 MultiplierSynthesisR17 MultiplierSynthesisDefault ) annotationsN)QuantumCircuit) Operation)LinearFunctionQFTGateXGateMCXGateC3XGateC4XGatePauliEvolutionGatePermutationGateMCMTGateModularAdderGate HalfAdderGate FullAdderGateMultiplierGateWeightedSumGateGlobalPhaseGate)AnnotatedOperationModifierControlModifierInverseModifier PowerModifier_canonicalize_modifiers) CouplingMap)synth_integer_comparator_2ssynth_integer_comparator_greedysynth_weighted_sum_carry)synth_clifford_fullsynth_clifford_layerssynth_clifford_depth_lnnsynth_clifford_greedysynth_clifford_agsynth_clifford_bm)synth_cnot_count_full_pmhsynth_cnot_depth_line_kmscalc_inverse_matrix)transpose_cx_circ)synth_permutation_basicsynth_permutation_acgsynth_permutation_depth_lnn_kms)synth_qft_fullsynth_qft_line) synth_mcx_n_dirty_i15synth_mcx_2_dirty_kg24synth_mcx_1_dirty_kg24synth_mcx_n_clean_m15synth_mcx_2_clean_kg24synth_mcx_1_clean_kg24synth_mcx_1_clean_b95synth_mcx_gray_codesynth_mcx_noaux_v24synth_mcx_noaux_hp24synth_mcmt_vchainsynth_mcmt_xgate)ProductFormulasynth_pauli_network_rustiq)adder_ripple_c04 adder_qft_d00adder_ripple_v95adder_ripple_r25adder_modular_v17multiplier_qft_r17multiplier_cumulative_h18)Clifford)ApproximateTokenSwapper)TranspilerError)EFFICIENTLY_CONTROLLED_GATES)OptimizationMetric)synthesize_operationHighLevelSynthesisData)HighLevelSynthesisPluginc"\rSrSrSrSSjrSrg)DefaultSynthesisCliffordiaaThe default clifford synthesis plugin. For N <= 3 qubits this is the optimal CX cost decomposition by Bravyi, Maslov. For N > 3 qubits this is done using the general non-optimal greedy compilation routine from reference by Bravyi, Hu, Maslov, Shaydulin. This plugin name is :``clifford.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc H[U[5(dg[U5nU$%Run synthesis for the given Clifford.N) isinstancerCrselfhigh_level_object coupling_maptargetqubitsoptions decompositions h/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/transpiler/passes/synthesis/hls_plugins.pyrunDefaultSynthesisClifford.runls$+X66+,=> NNN__name__ __module__ __qualname____firstlineno____doc__r[__static_attributes__r^r]rZrMrMas r]rMc"\rSrSrSrSSjrSrg)AGSynthesisCliffordiuzClifford synthesis plugin based on the Aaronson-Gottesman method. This plugin name is :``clifford.ag`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc H[U[5(dg[U5nU$rO)rQrCr#rRs rZr[AGSynthesisClifford.run|s$+X66)*;< r]r^r_r`r^r]rZrhrhu  r]rhc"\rSrSrSrSSjrSrg)BMSynthesisCliffordiaOClifford synthesis plugin based on the Bravyi-Maslov method. The method only works on Cliffords with at most 3 qubits, for which it constructs the optimal CX cost decomposition. This plugin name is :``clifford.bm`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc p[U[5(dgURS::a [U5nU$SnU$)rPN)rQrC num_qubitsr$rRs rZr[BMSynthesisClifford.runsA+X66  ' '1 ,-.?@M!Mr]r^r_r`r^r]rZrmrms  r]rmc"\rSrSrSrSSjrSrg)GreedySynthesisCliffordizClifford synthesis plugin based on the greedy synthesis Bravyi-Hu-Maslov-Shaydulin method. This plugin name is :``clifford.greedy`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc H[U[5(dg[U5nU$rO)rQrCr"rRs rZr[GreedySynthesisClifford.run$+X66-.?@ r]r^r_r`r^r]rZrsrs r]rsc"\rSrSrSrSSjrSrg)LayerSynthesisCliffordiaClifford synthesis plugin based on the Bravyi-Maslov method to synthesize Cliffords into layers. This plugin name is :``clifford.layers`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc H[U[5(dg[U5nU$rO)rQrCr rRs rZr[LayerSynthesisClifford.runrvr]r^r_r`r^r]rZryryrwr]ryc"\rSrSrSrSSjrSrg)LayerLnnSynthesisCliffordia8Clifford synthesis plugin based on the Bravyi-Maslov method to synthesize Cliffords into layers, with each layer synthesized adhering to LNN connectivity. This plugin name is :``clifford.lnn`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc H[U[5(dg[U5nU$rO)rQrCr!rRs rZr[LayerLnnSynthesisClifford.runs$+X6601BC r]r^r_r`r^r]rZr}r}s r]r}c"\rSrSrSrSSjrSrg)DefaultSynthesisLinearFunctionizThe default linear function synthesis plugin. This plugin name is :``linear_function.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc \[U[5(dg[UR5nU$)+Run synthesis for the given LinearFunction.N)rQrr%linearrRs rZr["DefaultSynthesisLinearFunction.runs*+^<<12C2J2JK r]r^r_r`r^r]rZrrrkr]rc"\rSrSrSrSSjrSrg)KMSSynthesisLinearFunctioniaLinear function synthesis plugin based on the Kutin-Moulton-Smithline method. This plugin name is :``linear_function.kms`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. The plugin supports the following plugin-specific options: * use_inverted: Indicates whether to run the algorithm on the inverse matrix and to invert the synthesized circuit. In certain cases this provides a better decomposition than the direct approach. * use_transposed: Indicates whether to run the algorithm on the transposed matrix and to invert the order of CX gates in the synthesized circuit. In certain cases this provides a better decomposition than the direct approach. Nc |[U[5(dgURSS5nURSS5nURR [ SS9nU(a[ R"U5nU(a [U5n[U5n U(a [U 5n U(aU R5n U $)rN use_invertedFuse_transposedcopy) rQrgetrastypeboolnp transposer'r&r(inverse) rSrTrUrVrWrXrrmatrYs rZr[KMSSynthesisLinearFunction.runs+^<<{{>59  %5u=&&--d-? ,,s#C %c*C1#6 -m`_ Nc [U[5(dgURSS5nURSS5nURSS5nURR [ SS9n U(a[ R"U 5n U(a [U 5n [XS9n U(a [U 5n U(aU R5n U $) rN section_sizerFrr)r) rQrrrrrrrr'r%r(r) rSrTrUrVrWrXrrrrrYs rZr[PMHSynthesisLinearFunction.run!s+^<<{{>15 {{>59  %5u=&&--d-? ,,s#C %c*C1#Q -m`_ 2. Donny Cheung, *Improved Bounds for the Approximate QFT* (2004), `arXiv:quant-ph/0403071 [quant-ph] `_ Nc  [U[5(dgURSS5nURSS5nURSS5nURSS5n URSS5n [URU(+UUU U S 9n U $) $Run synthesis for the given QFTGate.Nreverse_qubitsFapproximation_degreerinsert_barriersrname)rpdo_swapsrrrr)rQrrr,rp) rSrTrUrVrWrXrrrrrrYs rZr[QFTSynthesisFull.runs +W55 %5u=&{{+A1E!++&7?++i/{{64(&(33''!5+  r]r^r_r`r^r]rZrrks  Dr]rc"\rSrSrSrSSjrSrg)QFTSynthesisLineiuSynthesis plugin for QFT gates using linear connectivity. This plugin name is :``qft.line`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Note that the plugin mechanism is not applied if the gate is called ``qft`` but is not an instance of ``QFTGate``. This allows users to create custom gates with name ``qft``. The plugin supports the following additional options: * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``, which is the default) or the "QFT-with-reversal" operation (if ``True``). Some implementation of the ``QFTGate`` include a layer of swap gates at the end of the synthesized circuit, which can in principle be dropped if the ``QFTGate`` itself is the last gate in the circuit. * approximation_degree (int): the degree of approximation (0 for no approximation). It is possible to implement the QFT approximately by ignoring controlled-phase rotations with the angle beneath a threshold. This is discussed in more detail in [1] or [2]. References: 1. Adriano Barenco, Artur Ekert, Kalle-Antti Suominen, and Päivi Törmä, *Approximate Quantum Fourier Transform and Decoherence*, Physical Review A (1996). `arXiv:quant-ph/9601018 [quant-ph] `_ 2. Donny Cheung, *Improved Bounds for the Approximate QFT* (2004), `arXiv:quant-ph/0403071 [quant-ph] `_ Nc [U[5(dgURSS5nURSS5n[URU(+US9nU$)rNrFrr)rprr)rQrrr-rp) rSrTrUrVrWrXrrrYs rZr[QFTSynthesisLine.runs\ +W55 %5u=&{{+A1E&(33''!5 r]r^r_r`r^r]rZrrs >r]rc"\rSrSrSrSSjrSrg) TokenSwapperSynthesisPermutationia3The permutation synthesis plugin based on the token swapper algorithm. This plugin name is :``permutation.token_swapper`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. In more detail, this plugin is used to synthesize objects of type `PermutationGate`. When synthesis succeeds, the plugin outputs a quantum circuit consisting only of swap gates. When synthesis does not succeed, the plugin outputs `None`. If either `coupling_map` or `qubits` is None, then the synthesized circuit is not required to adhere to connectivity constraints, as is the case when the synthesis is done before layout/routing. On the other hand, if both `coupling_map` and `qubits` are specified, the synthesized circuit is supposed to adhere to connectivity constraints. At the moment, the plugin only creates swap gates between qubits in `qubits`, i.e. it does not use any other qubits in the coupling map (if such synthesis is not possible, the plugin outputs `None`). The plugin supports the following plugin-specific options: * trials: The number of trials for the token swapper to perform the mapping. The circuit with the smallest number of SWAPs is returned. * seed: The argument to the token swapper specifying the seed for random trials. * parallel_threshold: The argument to the token swapper specifying the number of nodes in the graph beyond which the algorithm will use parallel processing. For more details on the token swapper algorithm, see to the paper: `arXiv:1902.09102 `__. Nc [U[5(dgURSS5nURSS5nURSS5nURn [ U 5V V s0sHupX_M n n n UbUc [ R "[U 55n OURUSS 9n U RR5n[XS 9nURXUS 9nUb<[[UR!555nUHnUR""U6 M U$gs sn n f![Ra SnN^f=f) rNtrialsseedrparallel_threshold2F)check_if_connected)r)r)rQr rr enumerater from_fulllenreducegraph to_undirectedrDmaprxInvalidMappingr node_indicesswap)rSrTrUrVrWrXrrrrijpattern_as_dictused_coupling_maprswapperswapper_resultrYrs rZr[$TokenSwapperSynthesisPermutation.runsL+_==Xq){{61%$[[)=rB#++,5g,>?,>DA14,>?  6>!, 5 5c'l C !- 3 3Fu 3 U !''557)%; "$[[,r]rc"\rSrSrSrSSjrSrg)MCXSynthesisNDirtyI15i)aSynthesis plugin for a multi-controlled X gate based on the paper by Iten et al. (2016). See [1] for details. This plugin name is :``mcx.n_dirty_i15`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k\ge 4` control qubits this synthesis method requires :math:`k - 2` additional dirty auxiliary qubits. The synthesized circuit consists of :math:`2 * k - 1` qubits and at most :math:`8 * k - 6` CX gates. For :math:`k\le 3` explicit efficient circuits are used instead. The plugin supports the following plugin-specific options: * num_clean_ancillas: The number of clean auxiliary qubits available. * num_dirty_ancillas: The number of dirty auxiliary qubits available. * relative_phase: When set to ``True``, the method applies the optimized multi-controlled X gate up to a relative phase, in a way that, by lemma 8 of [1], the relative phases of the ``action part`` cancel out with the phases of the ``reset part``. * action_only: when set to ``True``, the method applies only the ``action part`` of lemma 8 of [1]. References: 1. Iten et. al., *Quantum Circuits for Isometries*, Phys. Rev. A 93, 032318 (2016), `arXiv:1501.06911 `_ Nc ,[U[[[45(dgURnUR SS5nUR SS5nUR SS5n UR SS5n US:a X-US - :ag[ XiU 5n U $) %Run synthesis for the given MCX gate.Nnum_clean_ancillasrnum_dirty_ancillasrelative_phaseF actions_onlyror)rQr r r num_ctrl_qubitsrr.) rSrTrUrVrWrXrrrr action_onlyrYs rZr[MCXSynthesisNDirtyI15.runFs+gw-HII +;;$[[)=qA$[[)=qA %5u=kk.%8 a $6$Ko`aNa$a-o{[ r]r^r_r`r^r]rZrr)s 8r]rc"\rSrSrSrSSjrSrg)MCXSynthesisNCleanM15i^aSynthesis plugin for a multi-controlled X gate based on the paper by Maslov (2016). See [1] for details. This plugin name is :``mcx.n_clean_m15`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k\ge 3` control qubits this synthesis method requires :math:`k - 2` additional clean auxiliary qubits. The synthesized circuit consists of :math:`2 * k - 1` qubits and at most :math:`6 * k - 6` CX gates. The plugin supports the following plugin-specific options: * num_clean_ancillas: The number of clean auxiliary qubits available. References: 1. Maslov., Phys. Rev. A 93, 022311 (2016), `arXiv:1508.03273 `_ Nc [U[[[45(dgURnUR SS5nUS:a XvS- :ag[ U5nU$)rNrrror)rQr r r rrr1 rSrTrUrVrWrXrrrYs rZr[MCXSynthesisNCleanM15.runtsa+gw-HII +;;$[[)=qA a $619L$L-o> r]r^r_r`r^r]rZrr^s *r]rc"\rSrSrSrSSjrSrg)MCXSynthesis1CleanB95ia:Synthesis plugin for a multi-controlled X gate based on the paper by Barenco et al. (1995). See [1] for details. This plugin name is :``mcx.1_clean_b95`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k\ge 5` control qubits this synthesis method requires a single additional clean auxiliary qubit. The synthesized circuit consists of :math:`k + 2` qubits and at most :math:`16 * k - 24` CX gates. The plugin supports the following plugin-specific options: * num_clean_ancillas: The number of clean auxiliary qubits available. References: 1. Barenco et. al., *Elementary gates for quantum computation*, Phys.Rev. A52 3457 (1995), `arXiv:quant-ph/9503016 `_ Nc [U[[[45(dgURnUS::agUR SS5nUS:aUS:Xag[ U5nU$)rNrrrr)rQr r r rrr4rs rZr[MCXSynthesis1CleanB95.runsi+gw-HII +;; a $[[)=qA a $6!$;-o> r]r^r_r`r^r]rZrrs *r]rc"\rSrSrSrSSjrSrg)MCXSynthesis2CleanKG24ia1Synthesis plugin for a multi-controlled X gate based on the paper by Khattar and Gidney (2024). See [1] for details. The plugin name is :``mcx.2_clean_kg24`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k\ge 3` control qubits this synthesis method requires :math:`2` additional clean ancillary qubits. The synthesized circuit consists of :math:`k + 3` qubits and at most :math:`6 * k - 6` CX gates. The plugin supports the following plugin-specific options: * num_clean_ancillas: The number of clean ancillary qubits available. References: 1. Khattar and Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits `arXiv:2407.17966 `__ Nc [U[[[45(dgURnUR SS5nUS:ag[ U5nU$)rNrrr)rQr r r rrr2rs rZr[MCXSynthesis2CleanKG24.runV+gw-HII +;;$[[)=qA  !.? r]r^r_r`r^r]rZrr *r]rc"\rSrSrSrSSjrSrg)MCXSynthesis2DirtyKG24ia3Synthesis plugin for a multi-controlled X gate based on the paper by Khattar and Gidney (2024). See [1] for details. The plugin name is :``mcx.2_dirty_kg24`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k\ge 3` control qubits this synthesis method requires :math:`2` additional dirty ancillary qubits. The synthesized circuit consists of :math:`k + 3` qubits and at most :math:`12 * k - 18` CX gates. The plugin supports the following plugin-specific options: * num_clean_ancillas: The number of clean ancillary qubits available. References: 1. Khattar and Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits `arXiv:2407.17966 `__ Nc [U[[[45(dgURnUR SS5UR SS5-nUS:ag[ U5nU$)rNrrrr)rQr r r rrr/ rSrTrUrVrWrXrrrYs rZr[MCXSynthesis2DirtyKG24.runn+gw-HII +;;$[[)=qAGKK !E    !.? r]r^r_r`r^r]rZrr *r]rc"\rSrSrSrSSjrSrg)MCXSynthesis1CleanKG24ia0Synthesis plugin for a multi-controlled X gate based on the paper by Khattar and Gidney (2024). See [1] for details. The plugin name is :``mcx.1_clean_kg24`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k\ge 3` control qubits this synthesis method requires :math:`1` additional clean ancillary qubit. The synthesized circuit consists of :math:`k + 2` qubits and at most :math:`6 * k - 6` CX gates. The plugin supports the following plugin-specific options: * num_clean_ancillas: The number of clean ancillary qubits available. References: 1. Khattar and Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits `arXiv:2407.17966 `__ Nc [U[[[45(dgURnUR SS5nUS:ag[ U5nU$)rNrrrJ)rQr r r rrr3rs rZr[MCXSynthesis1CleanKG24.run%rr]r^r_r`r^r]rZrrrr]rc"\rSrSrSrSSjrSrg)MCXSynthesis1DirtyKG24i9a2Synthesis plugin for a multi-controlled X gate based on the paper by Khattar and Gidney (2024). See [1] for details. The plugin name is :``mcx.1_dirty_kg24`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k\ge 3` control qubits this synthesis method requires :math:`1` additional dirty ancillary qubit. The synthesized circuit consists of :math:`k + 2` qubits and at most :math:`12 * k - 18` CX gates. The plugin supports the following plugin-specific options: * num_clean_ancillas: The number of clean ancillary qubits available. References: 1. Khattar and Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits `arXiv:2407.17966 `__ Nc [U[[[45(dgURnUR SS5UR SS5-nUS:ag[ U5nU$)rNrrrrJ)rQr r r rrr0rs rZr[MCXSynthesis1DirtyKG24.runOrr]r^r_r`r^r]rZrr9rr]rc"\rSrSrSrSSjrSrg)MCXSynthesisGrayCodeieaSynthesis plugin for a multi-controlled X gate based on the Gray code. This plugin name is :``mcx.gray_code`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k` control qubits this synthesis method requires no additional clean auxiliary qubits. The synthesized circuit consists of :math:`k + 1` qubits. It is not recommended to use this method for large values of :math:`k + 1` as it produces exponentially many gates. Nc v[U[[[45(dgURn[ U5nU$rN)rQr r r rr5rSrTrUrVrWrXrrYs rZr[MCXSynthesisGrayCode.runs9+gw-HII +;;+O< r]r^r_r`r^r]rZrres   r]rc"\rSrSrSrSSjrSrg)MCXSynthesisNoAuxV24iaSynthesis plugin for a multi-controlled X gate based on the implementation for MCPhaseGate, which is in turn based on the paper by Vale et al. (2024). See [1] for details. This plugin name is :``mcx.noaux_v24`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k` control qubits this synthesis method requires no additional clean auxiliary qubits. The synthesized circuit consists of :math:`k + 1` qubits. The number of CX-gates is quadratic in :math:`k`. References: 1. Vale et. al., *Circuit Decomposition of Multicontrolled Special Unitary Single-Qubit Gates*, IEEE TCAD 43(3) (2024), `arXiv:2302.06377 `_ Nc v[U[[[45(dgURn[ U5nU$r)rQr r r rr6rs rZr[MCXSynthesisNoAuxV24.runrr]r^r_r`r^r]rZrrs ( r]rc"\rSrSrSrSSjrSrg)MCXSynthesisNoAuxHP24iaSynthesis plugin for a multi-controlled X gate based on the paper by Huang and Palsberg. See [1] for details. This plugin name is :``mcx.noaux_hp24`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For a multi-controlled X gate with :math:`k` control qubits this synthesis method requires no additional clean auxiliary qubits. The synthesized circuit consists of :math:`k + 1` qubits. The number of CX-gates is linear in :math:`k`. References: 1. Huang and Palsberg, *Compiling Conditional Quantum Gates without Using Helper Qubits*, PLDI (2024), `_ Nc v[U[[[45(dgURn[ U5nU$r)rQr r r rr7rs rZr[MCXSynthesisNoAuxHP24.runs9+gw-HII +;;,_= r]r^r_r`r^r]rZrrs & r]rc"\rSrSrSrSSjrSrg)MCXSynthesisDefaultia{The default synthesis plugin for a multi-controlled X gate. This plugin name is :``mcx.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. The plugin supports the following plugin-specific options: * ``optimization_metric``: The optimization metric, indicating the property of the output circuit (e.g., the 2-qubit gate count or the T-count) that should be minimized. See :class:`.OptimizationMetric`. * ``num_clean_ancillas``: The number of clean ancillary qubits available. * ``num_dirty_ancillas``: The number of dirty ancillary qubits available. Nc [U[[[45(dgUR S[ R 5nU[ R:XaA[[[[[[[URS::a[ O["/nO@[[[[[[[URS::a[ O["/nUH$nU"5R$"XX440UD6=n cM"U s $ g)rNoptimization_metricr)rQr r r rrGCOUNT_2QCOUNT_Trrrrrrrrrrr[ rSrTrUrVrWrXmetricmethodsmethodrYs rZr[MCXSynthesisDefault.runs+gw-HII 24F4O4OP '// /'&&&%%%)88A=). G$'&%%&&%)88A=). GF!'%V"GN"   %$ r]r^r_r`r^r]rZr r s  6r]r c"\rSrSrSrSSjrSrg)MCMTSynthesisDefaultiz'A default decomposition for MCMT gates.Nc [U[5(dg[[4H$nU"5R"XX440UD6=ncM"Us $ [ 5R"XX440UD6$N)rQrMCMTSynthesisXGateMCMTSynthesisVChainr[MCMTSynthesisNoAux)rSrTrUrVrWrXsynthesis_methodrYs rZr[MCMTSynthesisDefault.runs+X66  !  "2!3!7!7%V"GN"   %$! "#''(9c[bccr]r^r_r`r^r]rZrrs 1dr]rc"\rSrSrSrSSjrSrg)ri(+A V-chain based synthesis for ``MCMTGate``.Nc *[U[5(dgURnURSS5nURS:XaY[ UR 5nURURURUS9UR5 UR5$[ URURS9n [UR5Hn U RXj//5 M U RURUS9nUR5$)N ctrl_staterJ)r")r)rQr base_gaternum_target_qubitsrrpappendcontrolrrWlabelrange decompose) rSrTrUrVrWrXr#r"circuitbasers rZr[MCMTSynthesisNoAux.run+s+X66%// [[t4  . .! 3$%6%A%ABG NN!!"3"C"CPZ![   "" ""3"E"EL]LcLcdD,>>? IsB/@ll#4#D#DQ[l\G  ""r]r^r_r`r^r]rZrr(s 5#r]rc"\rSrSrSrSSjrSrg)riDr Nc [U[5(dgURSS5URS- :agURSS5n[ UR URUR U5$)NrrrJr")rQrrrr8r#r$rSrTrUrVrWrXr"s rZr[MCMTSynthesisVChain.runGsr+X66 ;;+Q /2C2S2SVW2W W[[t4   ' '  - -  / /    r]r^r_r`r^r]rZrrDs 5 r]rc"\rSrSrSrSSjrSrg)riXz:A synthesis for ``MCMTGate`` with X gate as the base gate.Nc [U[5(dg[UR[5(dgUR SS5n[ UR URU5$)Nr")rQrr#rrr9rr$r/s rZr[MCMTSynthesisXGate.run[s\+X66+55u==[[t4   - -/@/R/RT^  r]r^r_r`r^r]rZrrXs D  r]rc"\rSrSrSrSSjrSrg)IntComparatorSynthesisDefaultihzxThe default synthesis for ``IntegerComparatorGate``. Currently this is only supporting an ancilla-based decomposition. Nc URS- nUS- nURSS5U:a [XaRUR5$[ XaRUR5$NrJrr)rprrvaluegeqr)rSrTrUrVrWrXnum_state_qubitsnum_auxs rZr[!IntComparatorSynthesisDefault.runnsq,77!;"Q& ;;+Q /' 92 "9"9;L;P;P + 557H7L7L  r]r^r_r`r^r]rZr5r5hs   r]r5c"\rSrSrSrSSjrSrg)IntComparatorSynthesisNoAuxi{zFA potentially exponentially expensive comparison w/o auxiliary qubits.Nc X[URURUR5$r)rr:r8r9rSrTrUrVrWrXs rZr[IntComparatorSynthesisNoAux.run~s*.  . .0A0G0GIZI^I^  r]r^r_r`r^r]rZr>r>{s P r]r>c"\rSrSrSrSSjrSrg)IntComparatorSynthesis2siz-An integer comparison based on 2s complement.Nc URS- nURSS5U:ag[URURUR5$r7)r:rrr8r9)rSrTrUrVrWrXr;s rZr[IntComparatorSynthesis2s.runsQ#44q8 ;;+Q /' 9*  . .0A0G0GIZI^I^  r]r^r_r`r^r]rZrCrCs 7 r]rCc"\rSrSrSrSSjrSrg)ModularAdderSynthesisDefaultiaThe default modular adder (no carry in, no carry out qubit) synthesis. This plugin name is:``ModularAdder.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. The plugin supports the following plugin-specific options: * ``optimization_metric``: The optimization metric, indicating the property of the output circuit (e.g., the 2-qubit gate count or the T-count) that should be minimized. See :class:`.OptimizationMetric`. * ``num_clean_ancillas``: The number of clean ancillary qubits available. * ``num_dirty_ancillas``: The number of dirty ancillary qubits available. Nc [U[5(dgURS[R5nU[R:XaG/nSUR s=::aS::aO OUR [5 UR [5 O[/nUH$nU"5R"XX440UD6=n cM"U s $ g)Nrr) rQrrrGrr:r%ModularAdderSynthesisD00ModularAdderSynthesisV17r[rs rZr[ ModularAdderSynthesisDefault.runs+-=>>24F4O4OP '00 0G%66;!;78 NN3 400GF!'%V"GN"   %$ r]r^r_r`r^r]rZrGrGs  r]rGc"\rSrSrSrSSjrSrg)rKiaA modular adder (modulo :math:`2^n`) without any ancillary qubits. The plugin name is :``ModularAdder.v17`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. This plugin requires no auxiliary qubits. Nc \[U[5(dgURn[U5$r)rQrr:r@rSrTrUrVrWrXr:s rZr[ModularAdderSynthesisV17.runs,+-=>>,== !122r]r^r_r`r^r]rZrKrKs 3r]rKc"\rSrSrSrSSjrSrg)ModularAdderSynthesisC04iaA ripple-carry adder, modulo :math:`2^n`. This plugin name is:``ModularAdder.ripple_c04`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. This plugin requires at least one clean auxiliary qubit. The plugin supports the following plugin-specific options: * ``num_clean_ancillas``: The number of clean auxiliary qubits available. Nc [U[5(dgURSS5S:ag[URSS9$)NrrrJfixedkind)rQrrr<r:r@s rZr[ModularAdderSynthesisC04.runsA+-=>> ;;+Q /! 3 1 B BQQr]r^r_r`r^r]rZrRrRs  Rr]rRc"\rSrSrSrSSjrSrg)ModularAdderSynthesisV95iaA ripple-carry adder, modulo :math:`2^n`. This plugin name is:``ModularAdder.ripple_v95`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For an adder on 2 registers with :math:`n` qubits each, this plugin requires at least :math:`n-1` clean auxiliary qubit. The plugin supports the following plugin-specific options: * ``num_clean_ancillas``: The number of clean auxiliary qubits available. Nc [U[5(dgURnUS- URSS5:ag[ USS9$)NrJrrrTrU)rQrr:rr>rOs rZr[ModularAdderSynthesisV95.runsL+-=>>,== a '++.BA"F F 0w??r]r^r_r`r^r]rZrYrYs   @r]rYc"\rSrSrSrSSjrSrg)rJizA QFT-based adder, modulo :math:`2^n`. This plugin name is:``ModularAdder.qft_d00`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc X[U[5(dg[URSSS9$)NrTTrV annotated)rQrr=r:r@s rZr[ModularAdderSynthesisD00.run s++-=>>.??gY]^^r]r^r_r`r^r]rZrJrJs  _r]rJc"\rSrSrSrSSjrSrg)HalfAdderSynthesisDefaultiaCThe default half-adder (no carry in, but a carry out qubit) synthesis. If we have an auxiliary qubit available, the Cuccaro ripple-carry adder uses :math:`O(n)` CX gates and 1 auxiliary qubit, whereas the Vedral ripple-carry uses more CX and :math:`n-1` auxiliary qubits. The QFT-based adder uses no auxiliary qubits, but :math:`O(n^2)`, hence it is only used if no auxiliary qubits are available. This plugin name is:``HalfAdder.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. If at least one clean auxiliary qubit is available, the :class:`HalfAdderSynthesisC04` is used, otherwise :class:`HalfAdderSynthesisD00`. The plugin supports the following plugin-specific options: * ``num_clean_ancillas``: The number of clean auxiliary qubits available. Nc [U[5(dgURS::a"[5R"XX440UD6=nbU$[ 5R"XX440UD6=nbU$[5R"XX440UD6$)Nro)rQrr:HalfAdderSynthesisR25r[HalfAdderSynthesisC04rRs rZr[HalfAdderSynthesisDefault.run%s+];;  . .! 3!6!8!rOs rZr[HalfAdderSynthesisV95.runjK+];;,== a '++.BA"F F 0v>>r]r^r_r`r^r]rZrlrl\   ?r]rlc"\rSrSrSrSSjrSrg)rdiwzA ripple-carry adder with a carry-out bit with no ancillary qubits. This plugin name is:``HalfAdder.ripple_r25`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc \[U[5(dgURn[U5$r)rQrr:r?rOs rZr[HalfAdderSynthesisR25.runs++];;,== 011r]r^r_r`r^r]rZrdrdws 2r]rdc"\rSrSrSrSSjrSrg)HalfAdderSynthesisD00izA QFT-based adder with a carry-in and a carry-out bit. This plugin name is:``HalfAdder.qft_d00`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc X[U[5(dg[URSSS9$)NriTr^)rQrr=r:r@s rZr[HalfAdderSynthesisD00.runs*+];;.??fX\]]r]r^r_r`r^r]rZrurus  ^r]ruc"\rSrSrSrSSjrSrg)FullAdderSynthesisDefaultizA ripple-carry adder with a carry-in and a carry-out bit. This plugin name is:``FullAdder.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc [U[5(dgURS:Xa![5R"XX440UD6nUbU$[ 5R"XX440UD6$)NrJ)rQrr:FullAdderSynthesisV95r[FullAdderSynthesisC04rRs rZr[FullAdderSynthesisDefault.runst+];;  - - 21377!CJM($$$&** V ?F  r]r^r_r`r^r]rZryrys   r]ryc"\rSrSrSrSSjrSrg)r|ia A ripple-carry adder with a carry-in and a carry-out bit. This plugin name is:``FullAdder.ripple_c04`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. This plugin requires no auxiliary qubits. Nc V[U[5(dg[URSS9$)NfullrU)rQrr<r:r@s rZr[FullAdderSynthesisC04.runs'+];; 1 B BPPr]r^r_r`r^r]rZr|r|s Qr]r|c"\rSrSrSrSSjrSrg)r{iaA ripple-carry adder with a carry-in and a carry-out bit. This plugin name is:``FullAdder.ripple_v95`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. For an adder on 2 registers with :math:`n` qubits each, this plugin requires at least :math:`n-1` clean auxiliary qubits. The plugin supports the following plugin-specific options: * ``num_clean_ancillas``: The number of clean auxiliary qubits available. Nc [U[5(dgURnUS- URSS5:ag[ USS9$)NrJrrrrU)rQrr:rr>rOs rZr[FullAdderSynthesisV95.runror]r^r_r`r^r]rZr{r{rpr]r{c"\rSrSrSrSSjrSrg)MultiplierSynthesisH18izA cumulative multiplier based on controlled adders. This plugin name is:``Multiplier.cumulative_h18`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc n[U[5(dg[URUR5$rrQrrBr:num_result_qubitsr@s rZr[MultiplierSynthesisH18.runs2+^<<(  . .0A0S0S  r]r^r_r`r^r]rZrr   r]rc"\rSrSrSrSSjrSrg)MultiplierSynthesisR17izA QFT-based multiplier. This plugin name is:``Multiplier.qft_r17`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc n[U[5(dg[URUR5$r)rQrrAr:rr@s rZr[MultiplierSynthesisR17.runs2+^<<!  . .0A0S0S  r]r^r_r`r^r]rZrrrr]rc"\rSrSrSrSSjrSrg)MultiplierSynthesisDefaultizTHe default multiplier plugin. This plugin name is:``Multiplier.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc n[U[5(dg[URUR5$rrr@s rZr[MultiplierSynthesisDefault.runs4+^<<)  . .0A0S0S  r]r^r_r`r^r]rZrrs   r]rc"\rSrSrSrSSjrSrg)PauliEvolutionSynthesisDefaulti aSynthesize a :class:`.PauliEvolutionGate` using the default synthesis algorithm. This plugin name is:``PauliEvolution.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. The following plugin option can be set: * preserve_order: If ``False``, allow re-ordering the Pauli terms in the Hamiltonian to reduce the circuit depth of the decomposition. Nc [U[5(dgURnURnSU;a[U[5(a USUlUR U5nXvlU$)Npreserve_order)rQr synthesisrr: synthesize) rSrTrUrVrWrXalgooriginal_preserve_order synth_objects rZr["PauliEvolutionSynthesisDefault.runsj+-?@@ **"&"5"5 w &:dN+K+K")*:";D '89 5r]r^r_r`r^r]rZrr s   r]rc"\rSrSrSrSSjrSrg)PauliEvolutionSynthesisRustiqi'uSynthesize a :class:`.PauliEvolutionGate` using Rustiq. This plugin name is :``PauliEvolution.rustiq`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. The Rustiq synthesis algorithm is described in [1], and is implemented in Rust-based quantum circuit synthesis library available at https://github.com/smartiel/rustiq-core. On large circuits the plugin may take a significant runtime. The plugin supports the following additional options: * optimize_count (bool): if `True` the synthesis algorithm will try to optimize the 2-qubit gate count; and if `False` then the 2-qubit depth. * preserve_order (bool): whether the order of paulis should be preserved, up to commutativity. * upto_clifford (bool): if `True`, the final Clifford operator is not synthesized. * upto_phase (bool): if `True`, the global phase of the returned circuit may differ from the global phase of the given pauli network. * resynth_clifford_method (int): describes the strategy to synthesize the final Clifford operator. Allowed values are `0` (naive approach), `1` (qiskit greedy synthesis), `2` (rustiq isometry synthesis). References: 1. Timothée Goubault de Brugière and Simon Martiel, *Faster and shorter synthesis of Hamiltonian simulation circuits*, `arXiv:2404.03280 [quant-ph] `_ Nc "[U[5(dgSSKJnJn [UR U5(a UR nO[UR U5(aUR UR 5nO[UR [5(aY/nUR HFn [X5(a"URUR U 55 M5URU 5 MH O [S5e[UURURURS9n U Rn [U [5(d[R"SS[ S9 gU R"n SU;a USU lU R$n U R'U 5nUR)S S 5nUR)SS 5nUR)S S 5nUR)S S 5nUR)SS5n[+U UUUUUUS9nXlU$)Nr) SparsePauliOpSparseObservablezInvalid PauliEvolutionGate.)timer'rzNCannot apply Rustiq if the evolution synthesis does not implement ``expand``. r) stacklevelcategoryroptimize_countT upto_cliffordF upto_phaseresynth_clifford_methodrJ)rp pauli_networkrrrrr)rQr qiskit.quantum_inforroperatorfrom_sparse_observablelistr%rErr'rr:warningswarnRuntimeWarningrrpexpandrr;)rSrTrUrVrWrXrrpauli_opopevorrrprrrrrrrs rZr[!PauliEvolutionSynthesisRustiq.runGs+-?@@G '00- @ @(11H )224D E E$;;Ar]rc\rSrSrSrS Sjr\S Sj5r\SSj5r\SSj5r\SSj5r \SS j5r \SS j5r S r g)AnnotatedSynthesisDefaultizSynthesize an :class:`.AnnotatedOperation` using the default synthesis algorithm. This plugin name is:``annotated.default`` which can be used as the key on an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`. Nc [U[5(dgURU5n[U[5(dURU5$UnURnUR SS5nUR SS5n UR SS5n U bU c [ S5e[[/SQ-5n [U RU RSSU RU RU U RSU RU R S9 n [#SU55n [#S U55n[#S U55S -nUR%5nU SU nXSnUR'U5 US:wdU(aUR)U5 [+UR,UU U5nUcURUR,5nO[.R0"US5nUR)U5 UR3U5nUcUR5UUR5nU$Uunnn[/UR65nUR9UUR:XR6S S 9 UR9UR5UUR5UR:S S 9 UR9UUR:XR6S S 9 U$)N qubit_trackerhls_data input_qubitszVThe AnnotatedSynthesisDefault plugin should receive data and input_qubits via options.)r_mcxqftr) hls_confighls_plugin_managerrUrVequivalence_library hls_op_names device_instsuse_physical_indices min_qubitsunroll_definitionsoptimize_clifford_tc3h# UH(n[U[5(dMURv M* g7fr)rQrr.0mods rZ 0AnnotatedSynthesisDefault.run..s#dis:cSbCc*s**i22c3h# UH(n[U[5(dMURv M* g7fr)rQrpowerrs rZrrsU#jm6TICIIrc3T# UHn[U[5(dMSv M g7f)rJN)rQrrs rZrrsUyJsO4T!!ys( (rT)inplace)rQr_canonicalize_op_instruction_to_circuit modifiersrrEsetrFrIrrrrrrrsumrdisable set_dirtyrHbase_opr_from_circuit_data_conjugate_decomposition_apply_annotationsrpcomposerW)rSrTrUrVrWrX operationrtrackerdatarbasisbase_synthesis_datanum_ctrlr is_invertedannotated_trackercontrol_qubits base_qubitssynthesized_base_op_resultsynthesized_base_opconjugate_decomp synthesizedfrontmiddlebacks rZr[AnnotatedSynthesisDefault.runs+-?@@!112CD+-?@@//0AB B% %// ++ot4{{:t,{{>48 <</!h $03NNO4#66 $ 8 8**!%!:!:#66 $ 8 8  diddUUUUyUUXYY ,$LLN%ix0"9- !!.1 A:  ' ' 4&:   {,?AR& " & -"&">">y?P?P"Q "0"C"CD^_`Da"b +& 889LM  #112EyGZGZ[K"%5 !UFD()=)=>K   {))(5I5IJTX     '' 0C0CD""     k((4H4HISW  r]c 4UGH n[U[5(aUR5nM+[U[5(GaURS:a [ S5e[ URUR-5nURS:wai[UR5RURSURSS9n[[SUR55nURXE5 UHnUR nUR"nURURSURSS9n[[SUR55UV s/sH*oRUR%U 5R&-PM, sn -nURXE5 M Un[U[(5(a [ S5eGM[U[*5(aUR-UR,5nGM[ SUS35e U$s sn f) z) Applies modifiers to a quantum circuit. rzHAnnotatedSynthesisDefault: cannot control a circuit with classical bits.NF)rr'r"r_zEAnnotatedSynthesisDefault: failed to synthesize the control modifier.z,AnnotatedSynthesisDefault: Unknown modifier .)rQrrr num_clbitsrErrrp global_phaserr&r"rr(r%rrWfind_bitindexrrr) r*rmodifiercontrolled_circuit controlled_opcontrolled_qubitsinstinst_op inst_qubitsqs rZr,AnnotatedSynthesisDefault._apply_annotations s "H(O44!//+Ho66%%))b &4H4L4LwOaOa4a%b"''1,$3G4H4H$I$Q$Q(0(@(@"#+#6#6"' %R%M )-U1h6N6N-O(P%&--mO#D"nnG"&++K$+OO(0(@(@"#+#6#6"' %4%M )-U1h6N6N-O(PVaTVaQR0073C3CA3F3L3LLVaT)%'--mO$-g'9::)_; Hm44!--7&(TU]T^^_&`aa]"`%Ts1H c[URUR5nURXRUR 5 U$z0Wraps a single operation into a quantum circuit.rrprr%rWclbitsrr*s rZr1AnnotatedSynthesisDefault._instruction_to_circuitN 3! >r>>7>>:r]c[URUR5nURXRUR 5 U$rrrs rZrrU rr]c2Un/n[U[5(a>URUR5 URn[U[5(aM>/nUSSS2HnUR U5 M [ U5nU(dU$[X5$)zF Combines recursive annotated operations and canonicalizes modifiers. N)rQrr%rrextendr)rcur all_modifiers new_modifiersrcanonical_modifierss rZr*AnnotatedSynthesisDefault._canonicalize_op\ s  011   /++C011 &tt,I   +-6mD"J!#;;r]cZSnURUR:wdFURUR:wd,[UR5[UR5:wagURnURn[ U[ 5n[ U[ 5nU(dU(dX4R5:HnU$U(d0U(a)UR[5/:XaX4R:HnU$U(d/U(a(UR[5/:XaURU:HnU$)zA very naive function that checks whether two circuit instructions are inverse of each other. The main use-case covered is a ``QFTGate`` and its inverse, represented as an ``AnnotatedOperation`` with a single ``InverseModifier``. F) rWrrparamsrrQrrrrr)inst1inst2resop1op2ann1ann2s rZ_are_inverse_ops*AnnotatedSynthesisDefault._are_inverse_opss s  LLELL (||u||+5<< C $55oooo#12#12D&C  $3==_5F4G#G$C $3==_5F4G#G++$C r]cUR5nSnUS- nX#:aO-[RXX5(a US- nUS-nOOM3US:XagUR5nSUl[ SU5HnUR X5 M UR5n[ X#S-5HnUR X5 M UR5nSUl[ US-U5HnUR X5 M XFU4$)a Decomposes a circuit ``A`` into 3 sub-circuits ``P``, ``Q``, ``R`` such that ``A = P -- Q -- R`` and ``R = P^{-1}``. This is accomplished by iteratively finding inverse nodes at the front and at the back of the circuit. The function returns ``None`` when ``P`` and ``R`` are empty. rrJN)sizerrcopy_empty_likerr(r%)r* num_gatesidxridx front_circuitrmiddle_circuit back_circuits rZr2AnnotatedSynthesisDefault._conjugate_decomposition sLLN 1}{(99', VVq  !8//1 %& "q#A   , 002s1H%A  ! !'* -&..0 $% !tax+A    +,|<>\+df  '(9::r]r^r_r`r^r]rZr)r) s  ;r]r))re __future__rrnumpyr rustworkxrqiskit.circuit.quantumcircuitrqiskit.circuit.operationrqiskit.circuit.libraryrrrr r r r r rrrrrrr"qiskit.circuit.annotated_operationrrrrrrqiskit.transpiler.couplingrqiskit.synthesis.arithmeticrrrqiskit.synthesis.cliffordrr r!r"r#r$qiskit.synthesis.linearr%r&r'-qiskit.synthesis.linear.linear_circuits_utilsr(qiskit.synthesis.permutationr)r*r+qiskit.synthesis.qftr,r-!qiskit.synthesis.multi_controlledr.r/r0r1r2r3r4r5r6r7r8r9qiskit.synthesis.evolutionr:r;r<r=r>r?r@rArBqiskit.quantum_info.operatorsrC+qiskit.transpiler.passes.routing.algorithmsrDqiskit.transpiler.exceptionsrEqiskit.circuit._add_controlrF%qiskit.transpiler.optimization_metricrG'qiskit._accelerate.high_level_synthesisrHrIpluginrKrMrhrmrsryr}rrrrrrrrrrrrrrrrrrrr rrrrr5r>rCrGrKrRrYrJrbrerlrdruryr|r{rrrrrrr)r^r]rZrGspd#8."3  L     R3O8DD`,7( 2  2.6"5" 8$ %=  '!9'T.!9.b 6   8  6  9/9x0/0fL'?L^242j(4(V-4-`'5'T)5)X'5'T)5)X3:!3!H 4 FG2GTd3d*#1#8 2 (  1   $< & ":   7  '#;'T373&R7R2@7@8 _7 _/ 8/ dQ4Q2?4?6 24 2 ^4 ^ 8 2 Q4 Q ?4?6  5   5   !9 "%=:a$<aHo= 8o=d ;":;r]