gdZddlmZddlZddlZddlZddlm Z ddl m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZddlmZmZmZmZmZmZddl m!Z!m"Z"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)dd l*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3dd l4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@ddlAmBZBGddeBZCGddeBZDGddeBZEGddeBZFGddeBZGGddeBZHGdd eBZIGd!d"eBZJGd#d$eBZKGd%d&eBZLGd'd(eBZMGd)d*eBZNGd+d,eBZOGd-d.eBZPGd/d0eBZQGd1d2eBZRGd3d4eBZSGd5d6eBZTGd7d8eBZUGd9d:eBZVGd;deBZXGd?d@eBZYGdAdBeBZZGdCdDeBZ[GdEdFeBZ\GdGdHeBZ]GdIdJeBZ^GdKdLeBZ_GdMdNeBZ`GdOdPeBZaGdQdReBZbGdSdTeBZcGdUdVeBZdGdWdXeBZeGdYdZeBZfGd[d\eBZgGd]d^eBZhGd_d`eBZidS)aaa& 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; use instead of ``"gray_code"`` for large values of `k` * - ``"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 * - ``"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 MCXSynthesisNCleanM15 MCXSynthesisNDirtyI15 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 * - ``"default"`` - :class:`~.MCMTSynthesisDefault` - any - any - chooses the best algorithm based on the ancillas available .. autosummary:: :toctree: ../stubs/ MCMTSynthesisVChain MCMTSynthesisNoAux MCMTSynthesisDefault 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 * - ``"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/ 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_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 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:`.HalfAdderGate` used - a cumulative adder based on controlled adders * - ``"qft"`` - :class:`.MultiplierSynthesisR17` - 0 - a QFT-based multiplier .. autosummary:: :toctree: ../stubs/ MultiplierSynthesisH18 MultiplierSynthesisR17 ) annotationsN)QuantumCircuit) LinearFunctionQFTGateMCXGateC3XGateC4XGatePauliEvolutionGatePermutationGateMCMTGateModularAdderGate HalfAdderGate FullAdderGateMultiplierGate) CouplingMap)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_n_clean_m15synth_mcx_1_clean_b95synth_mcx_gray_codesynth_mcx_noaux_v24synth_mcmt_vchain)ProductFormulasynth_pauli_network_rustiq)adder_ripple_c04 adder_qft_d00adder_ripple_v95multiplier_qft_r17multiplier_cumulative_h18)Clifford)ApproximateTokenSwapper)HighLevelSynthesisPluginceZdZdZddZdS)DefaultSynthesisCliffordaThe 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 Rt|tsdSt|}|S%Run synthesis for the given Clifford.N) isinstancer.rselfhigh_level_object coupling_maptargetqubitsoptions decompositions d/granary/edev/quantum/lib/python3.11/site-packages/qiskit/transpiler/passes/synthesis/hls_plugins.pyrunzDefaultSynthesisClifford.runs.+X66 4+,=>> NNN__name__ __module__ __qualname____doc__rArBr@r3r3s2rBr3ceZdZdZddZdS)AGSynthesisCliffordzClifford 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 Rt|tsdSt|}|Sr5)r7r.rr8s r@rAzAGSynthesisClifford.runs.+X66 4)*;<< rBrCrDrIrBr@rKrK2 rBrKceZdZdZddZdS)BMSynthesisCliffordacClifford 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 nt|tsdS|jdkrt|}nd}|S)r6N)r7r. num_qubitsrr8s r@rAzBMSynthesisClifford.run sC+X66 4  '1 , ,-.?@@MM MrBrCrDrIrBr@rOrOs2      rBrOceZdZdZddZdS)GreedySynthesisClifforda Clifford 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 Rt|tsdSt|}|Sr5)r7r.rr8s r@rAzGreedySynthesisClifford.run.+X66 4-.?@@ rBrCrDrIrBr@rTrT2rBrTceZdZdZddZdS)LayerSynthesisCliffordaClifford 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 Rt|tsdSt|}|Sr5)r7r.rr8s r@rAzLayerSynthesisClifford.run0rVrBrCrDrIrBr@rYrY(rWrBrYceZdZdZddZdS)LayerLnnSynthesisCliffordaLClifford 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 Rt|tsdSt|}|Sr5)r7r.rr8s r@rAzLayerLnnSynthesisClifford.runBs.+X66 401BCC rBrCrDrIrBr@r\r\9s2rBr\ceZdZdZddZdS)DefaultSynthesisLinearFunctionzThe 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 \t|tsdSt|j}|S)+Run synthesis for the given LinearFunction.N)r7rrlinearr8s r@rAz"DefaultSynthesisLinearFunction.runRs1+^<< 412C2JKK rBrCrDrIrBr@r_r_KrMrBr_ceZdZdZddZdS)KMSSynthesisLinearFunctionaLinear 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 t|tsdS|dd}|dd}|jt d}|rt j|}|rt|}t|} |rt| } |r| } | S)raN use_invertedFuse_transposedcopy) r7rgetrbastypeboolnp transposerrrinverse) r9r:r;r<r=r>rfrgmatr?s r@rAzKMSSynthesisLinearFunction.runls+^<< 4{{>599  %5u==&--d-??  $,s##C  +%c**C1#66  =-m<`_ Nc t|tsdS|dd}|dd}|dd}|jt d} |rt j| } |rt| } t| |} |rt| } |r| } | S) raN section_sizerfFrgrh)rt) r7rrjrbrkrlrmrnrrrro) r9r:r;r<r=r>rtrfrgrpr?s r@rAzPMHSynthesisLinearFunction.runs+^<< 4{{>155 {{>599  %5u==&--d-??  $,s##C  +%c**C1#LQQQ  =-m<`_ 2. Donny Cheung, *Improved Bounds for the Approximate QFT* (2004), `arXiv:quant-ph/0403071 [quant-ph] `_ Nc Ft|tsdS|dd}|dd}|dd}|dd} |dd} t|j| ||| | } | S) $Run synthesis for the given QFTGate.Nreverse_qubitsFapproximation_degreerinsert_barriersroname)rRdo_swapsrrror)r7rrjrrR) r9r:r;r<r=r>rrrrorr?s r@rAzQFTSynthesisFull.run s +W55 4 %5u==&{{+A1EE!++&7??++i//{{64((&(3''!5+    rBrCrDrIrBr@rrs3  DrBrceZdZdZddZdS)QFTSynthesisLineuZSynthesis 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 t|tsdS|dd}|dd}t|j| |}|S)rNrFrr)rRrr)r7rrjr rR) r9r:r;r<r=r>rrr?s r@rAzQFTSynthesisLine.runBsp +W55 4 %5u==&{{+A1EE&(3''!5   rBrCrDrIrBr@rr"s2>rBrceZdZdZddZdS) TokenSwapperSynthesisPermutationaThe 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 t|tsdS|dd}|dd}|dd}|j} dt | D} ||"t jt| } n||d } | j } t| | } | | || }n#tj$rd}YnwxYw|?tt| }|D] }|j| |SdS) rzNtrialsseedrparallel_threshold2ci|]\}}|| SrIrI).0ijs r@ z8TokenSwapperSynthesisPermutation.run..s???DAq1a???rBF)check_if_connected)r)r)r7r rjr{ enumerater from_fulllenreducegraph to_undirectedr/maprxInvalidMappingr node_indicesswap)r9r:r;r<r=r>rrrr{pattern_as_dictused_coupling_maprswapperswapper_resultr?rs r@rAz$TokenSwapperSynthesisPermutation.runus+_== 4Xq)){{61%%$[[)=rBB#+??Ig,>,>???  6>!, 5c'll C C  !- 3 3Fu 3 U U !'5577)%d;;; "$[[,,,,,,rBrceZdZdZddZdS)MCXSynthesisNDirtyI15aSynthesis 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 3` 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. 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 Vt|tttfsdS|j}|dd}|dd}|dd} |dd} |dkr||z|d z krdSt || | } | S) %Run synthesis for the given MCX gate.Nnum_clean_ancillasrnum_dirty_ancillasrelative_phaseF actions_onlyrQru)r7rrr num_ctrl_qubitsrjr!) r9r:r;r<r=r>rrrr action_onlyr?s r@rAzMCXSynthesisNDirtyI15.runs+gw-HII  4+;$[[)=qAA$[[)=qAA %5u==kk.%88 a  $69K$Ko`aNa$a$a4-o~{[[ rBrCrDrIrBr@rrs26rBrceZdZdZddZdS)MCXSynthesisNCleanM15a3Synthesis 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 t|tttfsdS|j}|dd}|dkr ||dz krdSt |}|S)rNrrrQru)r7rrr rrjr" r9r:r;r<r=r>rrr?s r@rAzMCXSynthesisNCleanM15.runsu+gw-HII  4+;$[[)=qAA a  $619L$L$L4-o>> rBrCrDrIrBr@rrs2*rBrceZdZdZddZdS)MCXSynthesis1CleanB95aASynthesis 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 - 8` 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., Phys.Rev. A52 3457 (1995), `arXiv:quant-ph/9503016 `_ Nc t|tttfsdS|j}|dkrdS|dd}|dkr|dkrdSt |}|S)rNrurrr)r7rrr rrjr#rs r@rAzMCXSynthesis1CleanB95.runs+gw-HII  4+; a  4$[[)=qAA a  $6!$;$;4-o>> rBrCrDrIrBr@rrs2*rBrceZdZdZddZdS)MCXSynthesisGrayCodea6Synthesis 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 zt|tttfsdS|j}t |}|SrN)r7rrr rr$r9r:r;r<r=r>rr?s r@rAzMCXSynthesisGrayCode.runA@+gw-HII  4+;+O<< rBrCrDrIrBr@rr3s2        rBrceZdZdZddZdS)MCXSynthesisNoAuxV24a Synthesis 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. References: 1. Vale et. al., *Circuit Decomposition of Multicontrolled Special Unitary Single-Qubit Gates*, IEEE TCAD 43(3) (2024), `arXiv:2302.06377 `_ Nc zt|tttfsdS|j}t |}|Sr)r7rrr rr%rs r@rAzMCXSynthesisNoAuxV24.rundrrBrCrDrIrBr@rrPs2&      rBrceZdZdZddZdS)MCXSynthesisDefaultzThe 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`. Nc Pt|tttfsdSt j||||fi|x} |St j||||fi|x} |Stj||||fi|x} |Stj||||fi|Sr) r7rrr rrArrrr8s r@rAzMCXSynthesisDefault.runzs7+gw-HII  4 92448!<CJ M   ! 92448!<CJ M   ! 92448!<CJ M   ! )#%%) |VV  ?F   rBrCrDrIrBr@rrss2 # # # # # # rBrceZdZdZddZdS)MCMTSynthesisDefaultz'A default decomposition for MCMT gates.Nc t|tsdStj||||fi|x} |St j||||fi|SN)r7r MCMTSynthesisVChainrAMCMTSynthesisNoAuxr8s r@rAzMCMTSynthesisDefault.runs+X66 470226!<CJ M   ! '!##'(9<QWcc[bcccrBrCrDrIrBr@rrs411 d d d d d drBrceZdZdZddZdS)r+A V-chain based synthesis for ``MCMTGate``.Nc t|tsdS|j}|dd}|jdkrJt |j}|||j ||j nft |j|j } t|jD]} | || gg| |j |}| S)N ctrl_stater0)r)r)r7r base_gaterjnum_target_qubitsrrRappendcontrolrr=labelrange decompose) r9r:r;r<r=r>rrcircuitbasers r@rAzMCMTSynthesisNoAux.runs +X66 4%/ [[t44  .! 3 3$%6%ABBG NN!!"3"CPZ![[     ""3"EL]LcdddD,>?? 0 0 IsB////ll#4#DQ[l\\G  """rBrCrDrIrBr@rrs.55######rBrceZdZdZddZdS)rrNc t|tsdS|dd|jdz krdS|dd}t |j|j|j|S)Nrrr0r)r7r rjrr&rr)r9r:r;r<r=r>rs r@rAzMCMTSynthesisVChain.runs}+X66 4 ;;+Q / /2C2SVW2W W W4[[t44   '  -  /     rBrCrDrIrBr@rrs.55      rBrceZdZdZddZdS)ModularAdderSynthesisDefaulta The 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`. If at least one clean auxiliary qubit is available, the :class:`ModularAdderSynthesisC04` is used, otherwise :class:`ModularAdderSynthesisD00`. The plugin supports the following plugin-specific options: * ``num_clean_ancillas``: The number of clean auxiliary qubits available. Nc t|tsdS|jdkr!tj||||fi|}||St j||||fi|x} |Stj||||fi|S)Nr)r7r num_state_qubitsModularAdderSynthesisD00rAModularAdderSynthesisC04r8s r@rAz ModularAdderSynthesisDefault.runs+-=>> 4  - 2 2:466:!<CJM($$<577;!<CJ M   ! .'))- |VV  ?F   rBrCrDrIrBr@rrs2        rBrceZdZdZddZdS)raA 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 t|tsdS|dddkrdSt|jdS)Nrrr0fixedkind)r7r rjr)rr9r:r;r<r=r>s r@rAzModularAdderSynthesisC04.runsS+-=>> 4 ;;+Q / /! 3 34 1 BQQQQrBrCrDrIrBr@rr s8  RRRRRRrBrceZdZdZddZdS)ModularAdderSynthesisV95aA 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 t|tsdS|j}|dz |ddkrdSt |dS)Nr0rrrr)r7r rrjr+r9r:r;r<r=r>rs r@rAzModularAdderSynthesisV95.run3s^+-=>> 4,= a '++.BA"F"F F F4 0w????rBrCrDrIrBr@rr$s8   @ @ @ @ @ @rBrceZdZdZddZdS)rzA 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 \t|tsdSt|jdS)Nrr)r7r r*rrs r@rAzModularAdderSynthesisD00.runGs2+-=>> 4.?gNNNNrBrCrDrIrBr@rr@s8 OOOOOOrBrceZdZdZddZdS)HalfAdderSynthesisDefaultaoThe 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 t|tsdS|jdkr!tj||||fi|}||St j||||fi|x} |St j||||fi|S)NrQ)r7rrHalfAdderSynthesisV95rAHalfAdderSynthesisC04HalfAdderSynthesisD00r8s r@rAzHalfAdderSynthesisDefault.runbs+];; 4  - 2 271337!<CJM($$92448!<CJ M   ! +$&&* |VV  ?F   rBrCrDrIrBr@rrNs2&      rBrceZdZdZddZdS)raA ripple-carry adder with a carry-out bit. This plugin name is:``HalfAdder.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 t|tsdS|dddkrdSt|jdS)Nrrr0halfr)r7rrjr)rrs r@rAzHalfAdderSynthesisC04.runsR+];; 4 ;;+Q / /! 3 34 1 BPPPPrBrCrDrIrBr@rr|s8  QQQQQQrBrceZdZdZddZdS)raA ripple-carry adder with a carry-out bit. This plugin name is:``HalfAdder.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 t|tsdS|j}|dz |ddkrdSt |dS)Nr0rrrr)r7rrrjr+rs r@rAzHalfAdderSynthesisV95.run]+];; 4,= a '++.BA"F"F F F4 0v>>>>rBrCrDrIrBr@rr2   ? ? ? ? ? ?rBrceZdZdZddZdS)rzA 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 \t|tsdSt|jdS)Nrr)r7rr*rrs r@rAzHalfAdderSynthesisD00.runs1+];; 4.?fMMMMrBrCrDrIrBr@rrs8 NNNNNNrBrceZdZdZddZdS)FullAdderSynthesisDefaultzA 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 t|tsdS|jdkr!tj||||fi|}||St j||||fi|S)Nr0)r7rrFullAdderSynthesisV95rAFullAdderSynthesisC04r8s r@rAzFullAdderSynthesisDefault.runs+];; 4  - 2 271337!<CJM($$*$&&* |VV  ?F   rBrCrDrIrBr@rrs2       rBrceZdZdZddZdS)raA 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 \t|tsdSt|jdS)Nfullr)r7rr)rrs r@rAzFullAdderSynthesisC04.runs1+];; 4 1 BPPPPrBrCrDrIrBr@rrs8QQQQQQrBrceZdZdZddZdS)raA 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 t|tsdS|j}|dz |ddkrdSt |dS)Nr0rrrr)r7rrrjr+rs r@rAzFullAdderSynthesisV95.runrrBrCrDrIrBr@rrrrBrceZdZdZddZdS)MultiplierSynthesisH18zA 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 dt|tsdSt|j|jSr)r7rr-rnum_result_qubitsrs r@rAzMultiplierSynthesisH18.run s8+^<< 4(  .0A0S   rBrCrDrIrBr@r r 2       rBr ceZdZdZddZdS)MultiplierSynthesisR17zA 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 dt|tsdSt|j|jSr)r7rr,rr rs r@rAzMultiplierSynthesisR17.runs8+^<< 4!  .0A0S   rBrCrDrIrBr@rrr rBrceZdZdZddZdS)PauliEvolutionSynthesisDefaultaSynthesize 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 t|tsdS|j}d|vr"t|tr |d|_||S)Npreserve_order)r7r synthesisr'r synthesize)r9r:r;r<r=r>algos r@rAz"PauliEvolutionSynthesisDefault.run/s`+-?@@ 4 * w & &:dN+K+K &")*:";D 0111rBrCrDrIrBr@rr"s2   2 2 2 2 2 2rBrceZdZdZddZdS)PauliEvolutionSynthesisRustiquSynthesize 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 t|tsdS|j}t|tst jddt dSd|vr |d|_|j}| |}| dd} | dd} | dd} | d d} | d d } t||| | | | | S) NzNCannot apply Rustiq if the evolution synthesis does not implement ``expand``. ru) stacklevelcategoryroptimize_countT upto_cliffordF upto_phaseresynth_clifford_methodr0)rR pauli_networkrrrrr) r7r rr'warningswarnRuntimeWarningrrRexpandrjr()r9r:r;r<r=r>rrRr rrrrrs r@rAz!PauliEvolutionSynthesisRustiq.run]s"+-?@@ 4 *$//  M`'     4 w & &")*:";D &1  $566  %5t<< %5t<< OU;; [[u55 ")++.G"K"K)!'))'!$;    rBrCrDrIrBr@rr=s2>$ $ $ $ $ $ rBr)jrH __future__rr!numpyrm rustworkxrqiskit.circuit.quantumcircuitrqiskit.circuit.libraryrrrrr r r r r rrrqiskit.transpiler.couplingrqiskit.synthesis.cliffordrrrrrrqiskit.synthesis.linearrrr-qiskit.synthesis.linear.linear_circuits_utilsrqiskit.synthesis.permutationrrrqiskit.synthesis.qftrr !qiskit.synthesis.multi_controlledr!r"r#r$r%r&qiskit.synthesis.evolutionr'r(qiskit.synthesis.arithmeticr)r*r+r,r-qiskit.quantum_info.operatorsr.+qiskit.transpiler.passes.routing.algorithmsr/pluginr1r3rKrOrTrYr\r_rdrrrwr}rrrrrrrrrrrrrrrrrrrrrrrrr rrrrIrBr@r6s IIV #"""""888888                            322222 LKKKKK RQQQQQQQ322222OOOOOO,,,,,,7(     2    2.6"5" 8$     %=    '''''!9'''T.....!9...b     6         8        6    99999/999x00000/000fLLLLL'?LLL^111114111h(((((4(((V-----4---`3:     3   F* * * * * 2* * * Zddddd3ddd$#####1###8     2   (& & & & & #;& & & RRRRRR7RRR2@@@@@7@@@8 O O O O O7 O O O+ + + + + 8+ + + \QQQQQ4QQQ2?????4???6 N N N N N4 N N N     8   2 Q Q Q Q Q4 Q Q Q ?????4???6      5         5    22222%=2226D D D D D $<D D D D D rB