z i^SrSSKJr SSKrSSKrSSKrSSKJrJrJ r J r SSK r SSK J r SSKJrJr SSKJrJr SSKJr SS KJrJrJrJr SS KJr SS KJr SS KJr SS K J!r!J"r"J#r$ SSK%J&r& \RN(aSSK(r(\RR\*\ \ \+4r,SSSjjr-"SS\&5r.SSjr/S S!Sjjr#\R`"SS5r1\"5r2S"Sjr3S#Sjr4S$Sjr5S%Sjr6S%Sjr7Sr8g)&zThe n-local circuit class.) annotationsN)CallableMappingSequenceIterable)Gate)QuantumCircuitParameterValueType)ParameterVectorParameterVectorElement)QuantumRegister) Instruction ParameterParameterExpressionCircuitInstruction) QiskitError)get_standard_gate_name_mapping)deprecate_func)Block py_n_localget_entangler_map)BlueprintCircuitc US:a[SU35e[5n [XU5n[X+U5n[U[ U55n[ UUUUUUUUU S9 n [ R"U SU S9n U $)uConstruct an n-local variational circuit. The structure of the n-local circuit are alternating rotation and entanglement layers. In both layers, parameterized circuit-blocks act on the circuit in a defined way. In the rotation layer, the blocks are applied stacked on top of each other, while in the entanglement layer according to the ``entanglement`` strategy. The circuit blocks can have arbitrary sizes (smaller equal to the number of qubits in the circuit). Each layer is repeated ``reps`` times, and by default a final rotation layer is appended. For instance, a rotation block on 2 qubits and an entanglement block on 4 qubits using ``"linear"`` entanglement yields the following circuit. .. parsed-literal:: ┌──────┐ ░ ┌──────┐ ░ ┌──────┐ ┤0 ├─░─┤0 ├──────────────── ... ─░─┤0 ├ │ Rot │ ░ │ │┌──────┐ ░ │ Rot │ ┤1 ├─░─┤1 ├┤0 ├──────── ... ─░─┤1 ├ ├──────┤ ░ │ Ent ││ │┌──────┐ ░ ├──────┤ ┤0 ├─░─┤2 ├┤1 ├┤0 ├ ... ─░─┤0 ├ │ Rot │ ░ │ ││ Ent ││ │ ░ │ Rot │ ┤1 ├─░─┤3 ├┤2 ├┤1 ├ ... ─░─┤1 ├ ├──────┤ ░ └──────┘│ ││ Ent │ ░ ├──────┤ ┤0 ├─░─────────┤3 ├┤2 ├ ... ─░─┤0 ├ │ Rot │ ░ └──────┘│ │ ░ │ Rot │ ┤1 ├─░─────────────────┤3 ├ ... ─░─┤1 ├ └──────┘ ░ └──────┘ ░ └──────┘ | | +---------------------------------+ repeated reps times Entanglement: The entanglement describes the connections of the gates in the entanglement layer. For a two-qubit gate for example, the entanglement contains pairs of qubits on which the gate should acts, e.g. ``[[ctrl0, target0], [ctrl1, target1], ...]``. A set of default entanglement strategies is provided and can be selected by name: * ``"full"`` entanglement is each qubit is entangled with all the others. * ``"linear"`` entanglement is qubit :math:`i` entangled with qubit :math:`i + 1`, for all :math:`i \in \{0, 1, ... , n - 2\}`, where :math:`n` is the total number of qubits. * ``"reverse_linear"`` entanglement is qubit :math:`i` entangled with qubit :math:`i + 1`, for all :math:`i \in \{n-2, n-3, ... , 1, 0\}`, where :math:`n` is the total number of qubits. Note that if ``entanglement_blocks=="cx"`` then this option provides the same unitary as ``"full"`` with fewer entangling gates. * ``"pairwise"`` entanglement is one layer where qubit :math:`i` is entangled with qubit :math:`i + 1`, for all even values of :math:`i`, and then a second layer where qubit :math:`i` is entangled with qubit :math:`i + 1`, for all odd values of :math:`i`. * ``"circular"`` entanglement is linear entanglement but with an additional entanglement of the first and last qubit before the linear part. * ``"sca"`` (shifted-circular-alternating) entanglement is a generalized and modified version of the proposed circuit 14 in `Sim et al. `__. It consists of circular entanglement where the "long" entanglement connecting the first with the last qubit is shifted by one each block. Furthermore the role of control and target qubits are swapped every block (therefore alternating). If an entanglement layer contains multiple blocks, then the entanglement should be given as list of entanglements for each block. For example:: entanglement_blocks = ["rxx", "ryy"] entanglement = ["full", "linear"] # full for rxx and linear for ryy or:: structure_rxx = [[0, 1], [2, 3]] structure_ryy = [[0, 2]] entanglement = [structure_rxx, structure_ryy] Finally, the entanglement can vary in each repetition of the circuit. For this, we support passing a callable that takes as input the layer index and returns the entanglement for the layer in the above format. See the examples below for a concrete example. Examples: The rotation and entanglement gates can be specified via single strings, if they are made up of a single block per layer: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: :context: from qiskit.circuit.library import n_local circuit = n_local(3, "ry", "cx", "linear", reps=2, insert_barriers=True) circuit.draw("mpl") Multiple gates per layer can be set by passing a list. Here, for example, we use Pauli-Y and Pauli-Z rotations in the rotation layer: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: :context: close-figs circuit = n_local(3, ["ry", "rz"], "cz", "full", reps=1, insert_barriers=True) circuit.draw("mpl") To omit rotation or entanglement layers, the block can be set to an empty list: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: :context: close-figs circuit = n_local(4, [], "cry", reps=2) circuit.draw("mpl") The entanglement can be set explicitly via the ``entanglement`` argument: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: :context: close-figs entangler_map = [[0, 1], [2, 0]] circuit = n_local(3, "x", "crx", entangler_map, reps=2) circuit.draw("mpl") We can set different entanglements per layer, by specifing a callable that takes as input the current layer index, and returns the entanglement structure. For example, the following uses different entanglements for odd and even layers: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: :context: close-figs def entanglement(layer_index): if layer_index % 2 == 0: return [[0, 1], [0, 2]] return [[1, 2]] circuit = n_local(3, "x", "cx", entanglement, reps=3, insert_barriers=True) circuit.draw("mpl") Args: num_qubits: The number of qubits of the circuit. rotation_blocks: The blocks used in the rotation layers. If multiple are passed, these will be applied one after another (like new sub-layers). entanglement_blocks: The blocks used in the entanglement layers. If multiple are passed, these will be applied one after another. entanglement: The indices specifying on which qubits the input blocks act. This is specified by string describing an entanglement strategy (see the additional info) or a list of qubit connections. If a list of entanglement blocks is passed, different entanglement for each block can be specified by passing a list of entanglements. To specify varying entanglement for each repetition, pass a callable that takes as input the layer and returns the entanglement for that layer. Defaults to ``"full"``, meaning an all-to-all entanglement structure. reps: Specifies how often the rotation blocks and entanglement blocks are repeated. insert_barriers: If ``True``, barriers are inserted in between each layer. If ``False``, no barriers are inserted. parameter_prefix: The prefix used if default parameters are generated. overwrite_block_parameters: If the parameters in the added blocks should be overwritten. If ``False``, the parameters in the blocks are not changed. skip_final_rotation_layer: Whether a final rotation layer is added to the circuit. skip_unentangled_qubits: If ``True``, the rotation gates act only on qubits that are entangled. If ``False``, the rotation gates act on all qubits. name: The name of the circuit. Returns: An n-local circuit. rz"reps must be non-negative, but is ) num_qubitsrotation_blocksentanglement_blocks entanglementrepsinsert_barriersparameter_prefixskip_final_rotation_layerskip_unentangled_qubitsT) legacy_qubitsname) ValueErrorr_normalize_blocks_normalize_entanglementlenrr _from_circuit_data)rrrrrr r!overwrite_block_parametersr"r#r%supported_gatesdatacircuits `/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/circuit/library/n_local/n_local.pyn_localr06sp ax=dVDEE46O'*DO,.H+<=P9QRL '/! ')"; 7 D//DtTG Nc^\rSrSrSr\"SSSS9S-S.U4Sjjj5r\S/Sj5r\RS0S j5r\S1S j5r \ RS2S j5r S3S jr \S4S j5r \ RS5Sj5r \S4Sj5r \ RS5Sj5r \S6Sj5r\RS7Sj5r\S/Sj5rS8S9Sjjr\S:Sj5r\RS;Sj5r\S1Sj5r\RSSj5rS?Sjr\S@Sj5rSASjr\SBS j5r\RSCS!j5r\SDS"j5r\RSES#j5rSFSGS$jjrSHSIU4S%jjjrSJS&jrS'rS(rS)r SKU4S*jjr!SLS+jr"S,r#U=r$$)MNLocali uB The n-local circuit class. The structure of the n-local circuit are alternating rotation and entanglement layers. In both layers, parameterized circuit-blocks act on the circuit in a defined way. In the rotation layer, the blocks are applied stacked on top of each other, while in the entanglement layer according to the ``entanglement`` strategy. The circuit blocks can have arbitrary sizes (smaller equal to the number of qubits in the circuit). Each layer is repeated ``reps`` times, and by default a final rotation layer is appended. For instance, a rotation block on 2 qubits and an entanglement block on 4 qubits using ``'linear'`` entanglement yields the following circuit. .. code-block:: text ┌──────┐ ░ ┌──────┐ ░ ┌──────┐ ┤0 ├─░─┤0 ├──────────────── ... ─░─┤0 ├ │ Rot │ ░ │ │┌──────┐ ░ │ Rot │ ┤1 ├─░─┤1 ├┤0 ├──────── ... ─░─┤1 ├ ├──────┤ ░ │ Ent ││ │┌──────┐ ░ ├──────┤ ┤0 ├─░─┤2 ├┤1 ├┤0 ├ ... ─░─┤0 ├ │ Rot │ ░ │ ││ Ent ││ │ ░ │ Rot │ ┤1 ├─░─┤3 ├┤2 ├┤1 ├ ... ─░─┤1 ├ ├──────┤ ░ └──────┘│ ││ Ent │ ░ ├──────┤ ┤0 ├─░─────────┤3 ├┤2 ├ ... ─░─┤0 ├ │ Rot │ ░ └──────┘│ │ ░ │ Rot │ ┤1 ├─░─────────────────┤3 ├ ... ─░─┤1 ├ └──────┘ ░ └──────┘ ░ └──────┘ | | +---------------------------------+ repeated reps times If specified, barriers can be inserted in between every block. If an initial state object is provided, it is added in front of the NLocal. .. seealso:: The :func:`.n_local` function constructs a functionally equivalent circuit, but faster. z2.1z}This applies to NLocal subclasses too. Use the corresponding function from the module qiskit.circuit.library.n_local instead.z in Qiskit 3.0)sinceadditional_msgremoval_timelinec6>[TU]U S9 SUlX`lXPl/Ul/Ul/Ul/Ul/Ul /Ul SUl SUl [US9UlXlXlXlSUlSUlSUlXl[-UR.SS5[0R.LUl[5U5U:wa [7S5eUS:a [9S5eUbXlUbX0lUbX lUbX@l U bXl!gg)a0 Args: num_qubits: The number of qubits of the circuit. rotation_blocks: The blocks used in the rotation layers. If multiple are passed, these will be applied one after another (like new sub-layers). entanglement_blocks: The blocks used in the entanglement layers. If multiple are passed, these will be applied one after another. To use different entanglements for the sub-layers, see :meth:`get_entangler_map`. entanglement: The indices specifying on which qubits the input blocks act. If ``None``, the entanglement blocks are applied at the top of the circuit. reps: Specifies how often the rotation blocks and entanglement blocks are repeated. insert_barriers: If ``True``, barriers are inserted in between each layer. If ``False``, no barriers are inserted. parameter_prefix: The prefix used if default parameters are generated. overwrite_block_parameters: If the parameters in the added blocks should be overwritten. If ``False``, the parameters in the blocks are not changed. skip_final_rotation_layer: Whether a final rotation layer is added to the circuit. skip_unentangled_qubits: If ``True``, the rotation gates act only on qubits that are entangled. If ``False``, the rotation gates act on all qubits. initial_state: A :class:`.QuantumCircuit` object which can be used to describe an initial state prepended to the NLocal circuit. name: The name of the circuit. flatten: Set this to ``True`` to output a flat circuit instead of nesting it inside multiple layers of gate objects. By default currently the contents of the output circuit will be wrapped in nested objects for cleaner visualization. However, if you're using this circuit for anything besides visualization its **strongly** recommended to set this flag to ``True`` to avoid a large performance overhead for parameter binding. Raises: ValueError: If ``reps`` parameter is less than or equal to 0. TypeError: If ``reps`` parameter is not an int value. r%N__func__zThe value of reps should be intrz5The value of reps should be larger than or equal to 0)"super__init__ _num_qubits_insert_barriers_reps_entanglement_blocks_rotation_blocks_prepended_blocks_prepended_entanglement_appended_blocks_appended_entanglement _entanglement_entangler_mapsr _ordered_parameters_overwrite_block_parameters_skip_final_rotation_layer_skip_unentangled_qubits_initial_state_initial_state_circuit_bounds_flattengetattr_parameter_generatorr3 _allow_fast_path_parametrizationint TypeErrorr&rrrr initial_state)selfrrrrrr r!r+r"r#rTr%flatten __class__s r/r;NLocal.__init__7s?H d#'+ / :<!6879DF$68CE#!#FU!G  ,F(*C'(?%59=A#GK   D--z4 @FD_D_ _ - t9 => > !8TU U  !(O  *': $    # ,   $!.  %r1c8URb UR$S$)zRReturns the number of qubits in this circuit. Returns: The number of qubits. r)r<rUs r/rNLocal.num_qubitss $(#3#3#?tFQFr1crURU:wa'UR5 Xl[USS9/Ulgg)zWSet the number of qubits for the n-local circuit. Args: The new number of qubits. qr8N)r< _invalidater qregs)rUrs r/rr[s:   z )    ) )*3?@DJ *r1c,[UR5$)zQReturns whether the circuit is wrapped in nested gates/instructions or flattened.)boolrNrZs r/rVNLocal.flattensDMM""r1c0UR5 XlgN)r^rN)rUrVs r/rVrbs  r1c[U[5(aU$[U[5(aE[UR5nUR U[ [ UR555 U$[UR5nUR UR5[ [ UR555 U$![a Of=f[S[U5S35e)zTry to convert ``layer`` to a QuantumCircuit. Args: layer: The object to be converted to an NLocal block / Instruction. Returns: The layer converted to a circuit. Raises: TypeError: If the input cannot be converted to a circuit. z Adding a z to an NLocal is not supported.) isinstancer rrappendlistrangeto_instructionAttributeErrorrStype)rUlayerr.s r/_convert_to_blockNLocal._convert_to_blocks e^ , ,L e[ ) )$U%5%56G NN5$uU-=-='>"? @N $U%5%56G NN5//14e>N>N8O3P QN   )DK=0OPQQs3AC CCcUR$)zTThe blocks in the rotation layers. Returns: The blocks in the rotation layers. )r@rZs r/rNLocal.rotation_blocks$$$r1c[U[[R45(dU/nUR 5 UVs/sHo R U5PM snUlgs snf)zbSet the blocks in the rotation layers. Args: blocks: The new blocks for the rotation layers. N)rfrhnumpyndarrayr^rnr@rUblocksblocks r/rrqsP&4"788XF LR SF5!7!7!>F S SA cUR$)z\The blocks in the entanglement layers. Returns: The blocks in the entanglement layers. )r?rZs r/rNLocal.entanglement_blocks s(((r1c[U[[R45(dU/nUR 5 UVs/sHo R U5PM snUlgs snf)zjSet the blocks in the entanglement layers. Args: blocks: The new blocks for the entanglement layers. N)rfrhrtrur^rnr?rvs r/rr{sR&4"788XF PV$WPVu%;%;E%BPV$W!$WrycUR$)zGet the entanglement strategy. Returns: The entanglement strategy, see :meth:`get_entangler_map` for more detail on how the format is interpreted. )rErZs r/rNLocal.entanglement"s(!!!r1c0UR5 Xlg)zSet the entanglement strategy. Args: entanglement: The entanglement strategy. See :meth:`get_entangler_map` for more detail on the supported formats. N)r^rE)rUrs r/rr~8s, )r1cVSUR-[UR(+5-$)zgReturn the number of layers in the n-local circuit. Returns: The number of layers in the circuit. r)r>rRrIrZs r/ num_layersNLocal.num_layersQs%4::~(G(G$G HHHr1cSnURcSnU(a [S5eURc!URcSnU(a [S5eU$)aCheck if the configuration of the NLocal class is valid. Args: raise_on_failure: Whether to raise on failure. Returns: True, if the configuration is valid and the circuit can be constructed. Otherwise an ValueError is raised. Raises: ValueError: If the blocks are not set. ValueError: If the number of repetitions is not set. ValueError: If the qubit indices are not set. ValueError: If the number of qubit indices does not match the number of blocks. ValueError: If an index in the repetitions list exceeds the number of blocks. ValueError: If the number of repetitions does not match the number of block-wise parameters. ValueError: If a specified qubit index is larger than the (manually set) number of qubits. TFzNo number of qubits specified.zThe blocks are not set.)rr&rr)rUraise_on_failurevalids r/_check_configurationNLocal._check_configurationZsY* ?? "E !ABB  # # +0D0D0LE !:;; r1c[UR[5(a:URRUR5 [ UR5$UR$)uThe parameters used in the underlying circuit. This includes float values and duplicates. Examples: >>> # prepare circuit ... >>> print(nlocal) ┌───────┐┌──────────┐┌──────────┐┌──────────┐ q_0: ┤ Ry(1) ├┤ Ry(θ[1]) ├┤ Ry(θ[1]) ├┤ Ry(θ[3]) ├ └───────┘└──────────┘└──────────┘└──────────┘ >>> nlocal.parameters {Parameter(θ[1]), Parameter(θ[3])} >>> nlocal.ordered_parameters [1, Parameter(θ[1]), Parameter(θ[1]), Parameter(θ[3])] Returns: The parameters objects used in the circuit. )rfrGr resizenum_parameters_settablerhrZs r/ordered_parametersNLocal.ordered_parameters}sN* d.. @ @  $ $ + +D,H,H I001 1'''r1c[U[5(d=[U5UR:wa$[ SURS[U535eXlUR 5 g)aXSet the parameters used in the underlying circuit. Args: The parameters to be used in the underlying circuit. Raises: ValueError: If the length of ordered parameters does not match the number of parameters in the circuit and they are not a ``ParameterVector`` (which could be resized to fit the number of parameters). zdThe length of ordered parameters must be equal to the number of settable parameters in the circuit (z ), but is N)rfr r)rr&rGr^)rU parameterss r/rrsj:77J4#?#??77;7S7S6TUz?+-  $.  r1cUR$)zIf barriers are inserted in between the layers or not. Returns: ``True``, if barriers are inserted in between the layers, ``False`` if not. )r=rZs r/r NLocal.insert_barriersrrr1cNXRLaUR5 Xlgg)zSpecify whether barriers should be inserted in between the layers or not. Args: insert_barriers: If True, barriers are inserted, if False not. N)r=r^)rUr s r/r rs' "7"7 7    $3 ! 8r1c l[5n[UR5Hin[UR5HMup4UR X#UR 5nURUVVs/sH ofHowPM M snn5 MO Mk [[UR 55U- nU$s snnf)zVGet the indices of unentangled qubits in a set. Returns: The unentangled qubits. )setrir> enumeraterrrupdate) rUentangled_qubitsijrx entangler_mapindicesidxunentangled_qubitss r/get_unentangled_qubitsNLocal.get_unentangled_qubitss 5tzz"A%d&>&>? $ 6 6qU=M=M N  ''M(]MU\cU\M(]^@#!t!78;KK!!)^s)B0c dSn[UR5H`n[UR5HDup4UR X#UR 5nU[ U5[ [U55-- nMF Mb UR(aUR5nSnURHn[UR UR -5Vs/sH4n[[X4R -US-UR -55PM6 nnUR(a3UV s/sH&n [U 5RW5(dM$U PM( nn U[ U5[ [U55-- nM XUR[UR(+5--- nU$s snfs sn f)aThe number of total parameters that can be set to distinct values. This does not change when the parameters are bound or exchanged for same parameters, and therefore is different from ``num_parameters`` which counts the number of unique :class:`~qiskit.circuit.Parameter` objects currently in the circuit. Returns: The number of parameters originally available in the circuit. Note: This quantity does not require the circuit to be built yet. r)rir>rrrrr)get_parametersrJrrrhr isdisjointrRrI) rUnumrrrxrrnum_rot block_indicesrs r/rNLocal.num_parameters_settablestzz"A%d&>&>? $ 6 6qU=M=M N s=)Cu0E,FFF@#  ( (!%! ))Et%2B2BBCCAU1///!a%5;K;K1KLMC ,,$1!#07|../AB#0! s=)Cu0E,FF FG* $**st/N/N+N'OOPP  !s;F($#F- F-cUR$)zkThe number of times rotation and entanglement block are repeated. Returns: The number of repetitions. )r>rZs r/r NLocal.repsszzr1crUS:a [S5eXR:waUR5 Xlgg)a%Set the repetitions. If the repetitions are `0`, only one rotation layer with no entanglement layers is applied (unless ``self.skip_final_rotation_layer`` is set to ``True``). Args: repetitions: The new repetitions. Raises: ValueError: If reps setter has parameter repetitions < 0. rz3The repetitions should be larger than or equal to 0N)r&r>r^)rU repetitionss r/rrs7 ?RS S ** $    $J %r1cSURRS3nSnURR5Hup4USS:XdMUSUSSS US3- nM! X- nU$) z~Returns information about the setting. Returns: The class name and the attributes/parameters of the instance as ``str``. zNLocal:  r_z-- rNz: )rW__name____dict__items)rUretparamskeyvalues r/print_settingsNLocal.print_settingssv 0014----/JC1v}CABy5'440  r1cg)zThe initial points for the parameters. Can be stored as initial guess in optimization. Returns: The initial values for the parameters, or None, if none have been set. NrZs r/preferred_init_pointsNLocal.preferred_init_points)sr1c XUpenURnUc[[U55/$[U5(aU"U5n[ U[ 5(a[ X`RXtS9$[ U[[45(d[SU35e[U5n[SU55(a[ X`RXtU-US9$[SU55(aUV s/sHn [U 5PM sn /$[SU55(d[SU35e[XtU-5n [SU55(a[ X`RXtU-XZ-US9$[SU55(a1[U5H up[[[U 55X{'M" U$[SU55(d[SU35e[S U55(a?UH2n [U 5H up[[[U 55X'M" M4 XtU-$[S U55(d[SU35e[S U55(aMUH;n U H2n [U 5H up[[[U 55X'M" M4 M= XtU-XZ-$[SU35es sn f) ajGet the entangler map for in the repetition ``rep_num`` and the block ``block_num``. The entangler map for the current block is derived from the value of ``self.entanglement``. Below the different cases are listed, where ``i`` and ``j`` denote the repetition number and the block number, respectively, and ``n`` the number of qubits in the block. =================================== ======================================================== entanglement type entangler map =================================== ======================================================== ``None`` ``[[0, ..., n - 1]]`` ``str`` (e.g ``'full'``) the specified connectivity on ``n`` qubits ``List[int]`` [``entanglement``] ``List[List[int]]`` ``entanglement`` ``List[List[List[int]]]`` ``entanglement[i]`` ``List[List[List[List[int]]]]`` ``entanglement[i][j]`` ``List[str]`` the connectivity specified in ``entanglement[i]`` ``List[List[str]]`` the connectivity specified in ``entanglement[i][j]`` ``Callable[int, str]`` same as ``List[str]`` ``Callable[int, List[List[int]]]`` same as ``List[List[List[int]]]`` =================================== ======================================================== Note that all indices are to be taken modulo the length of the array they act on, i.e. no out-of-bounds index error will be raised but we re-iterate from the beginning of the list. Args: rep_num: The current repetition we are in. block_num: The block number within the entanglement layers. num_block_qubits: The number of qubits in the block. Returns: The entangler map for the current block in the current repetition. Raises: ValueError: If the value of ``entanglement`` could not be cast to a corresponding entangler map. )offsetzInvalid value of entanglement: c3B# UHn[U[5v M g7frdrfstr.0ens r/ +NLocal.get_entangler_map..qs:\rz"c""\c3b# UH%n[U[[R45v M' g7frd)rfrRrtintegerrs r/rrus#Klz"sEMM233ls-/c3N# UHn[U[[45v M g7frdrftuplerhrs r/rrysH>`b>sAAc3`# UH$oHn[U[[45v M M& g7frdrrs r/rrs)UnUH4n[U[[R[R45v M6 M@ MJ g7frdrrrre3s r/rrsL " rCekk: ; ; < <"sAAc3r# UH-oH$o"Hn[U[[45v M M& M/ g7frdrrs r/rrs5bnUH4n[U[[R[R45v M6 M@ MJ MT g7frdr)rrrre4s r/rrs[ " rCekk: ; ; < < <"sAA)rErhricallablerfrrrrr&r)allrRrmap)rUrep_num block_numnum_block_qubitsrrnrnum_irnum_jindrrs r/rNLocal.get_entangler_map3sR&6a))   qN# # L ! !'?L lC ( ($QP P, 66>|nMN NL! :\: : :$Q%i9PYZ[ [ KlK K K'34|SW|45 5H<HHH>|nMN NLU+, G\G G G$??LU$;AI$Fq  cc c c$\2$)#c2,$7 !3 U<UUU>|nMN N  "   #(}GC#CRL1BG -# E * *b<bbb>|nMN N  "   #B#,R="'C "5$1# E *195 5:<.IJJk5s*KcUR$)ziReturn the initial state that is added in front of the n-local circuit. Returns: The initial state. )rKrZs r/rTNLocal.initial_states"""r1c0XlUR5 g)zSet the initial state. Args: initial_state: The new initial state. Raises: ValueError: If the number of qubits has been set before and the initial state does not match the number of qubits. N)rKr^)rUrTs r/rTrs, r1c\UR(dUR5 UR$)a The parameter bounds for the unbound parameters in the circuit. Returns: A list of pairs indicating the bounds, as (lower, upper). None indicates an unbounded parameter in the corresponding direction. If ``None`` is returned, problem is fully unbounded. ) _is_built_buildrMrZs r/parameter_boundsNLocal.parameter_boundss~~ KKM||r1cXlg)zGSet the parameter bounds. Args: bounds: The new parameter bounds. N)rM)rUboundss r/rrs  r1cURU5nUc [[UR55/nO0[ U[5(a[ US[5(dU/nU(a-U=R U/- slU=R U/- slO,U=RU/- slU=RU/- sl[ U[5(a:S[SU55-nXPR:aUR5 XPlUSLaUR(aUR(a)[UR5S:aUR5 [ U[ 5(a"[#URURU5nOUnUHEnUR$[['U55*SnUR)XHS9n UR+XSSS9 MG U$UR5 U$) aAppend another layer to the NLocal. Args: other: The layer to compose, can be another NLocal, an Instruction or Gate, or a QuantumCircuit. entanglement: The entanglement or qubit indices. front: If True, ``other`` is appended to the front, else to the back. Returns: self, such that chained composes are possible. Raises: TypeError: If `other` is not compatible, i.e. is no Instruction and does not have a `to_instruction` method. Nrrc38# UHn[U5v M g7frd)max)rrs r/r#NLocal.add_layer..s J\'W\sF)rTinplacecopy)rnrhrirrfrArBrCrDrr^rr=r)r-barrierrrrr_parameterize_blockcompose) rUotherrfrontrxrrrrparameterized_blocks r/ add_layerNLocal.add_layers*&&u-   u'7'7!89:L  d + +J|APT4U4U(>L   " "ug - "  ( (\N : (  ! !eW , !  ' 'L> 9 ' lD ) )S J\ JJJJOO+  "", E>dnn$$TYY!); ,,,9J$$doo|: !- "00#nU6K2L1L1NO&*&>&>u&>&T# 0T N#      r1c >Ub[U5S:XaU$UR(dUR5 [TU]"U4SU0UD6$)aAssign parameters to the n-local circuit. This method also supports passing a list instead of a dictionary. If a list is passed, the list must have the same length as the number of unbound parameters in the circuit. The parameters are assigned in the order of the parameters in :meth:`ordered_parameters`. Returns: A copy of the NLocal circuit with the specified parameters. Raises: AttributeError: If the parameters are given as list and do not match the number of parameters. rr)r)rrr:assign_parameters)rUrrkwargsrWs r/rNLocal.assign_parameterssE,  ZA!5K~~ KKMw(OWOOOr1cJUR(a~UcURX4U5nUc6[[[ U555Vs/sHn[ U5PM nn[ [URU55nURU5$UR5$s snf)zUConvert ``block`` to a circuit of correct width and parameterized using the iterator.) rHrPrir)rnextdictziprrr) rUrx param_iterrrrrrrs r/rNLocal._parameterize_block6s  + +~227wO~49#nU>S:T4UV4Uq$z*4UV#e..78F**62 2zz| Ws B c |^^^UR(aUR5nO [5nURm[ UR 5GH]unmUVs1sHofTR -iM snmUR(a[T5=nbUUU4Sj[UR TR -55nUHKn [UR"[R"X'R56U 5n URU 5 MM M[UR TR -5V s/sH=n U T;dM [![U TR -U S-TR -55PM? n n U H'n UR#TX#X]5nUR%XSSS9 M) GM` gs snfs sn f)zBuild a rotation layer.Nc3># UH8nUT;dM [TUTR-US-TR-5v M: g7f)rN)rr)rkrxskipped_blocks target_qubitss r/r/NLocal._build_rotation_layer..XsLG.\E-E,<,<(<AIYIY?YZ[[Gs A2ArTFr)rJrrqubitsrrrrQ_stdlib_gate_from_simple_blockrirgate itertoolsislice num_params_appendrhrr)rUr.rrskipped_qubitsrqubit simple_block all_qubitsrinstrr rrrrxr r s @@@r/_build_rotation_layerNLocal._build_rotation_layerGs  ( (!88:N UN "$"6"67HAuEST^Eu'7'77^TN55%CE%JJ\W"4??e6F6F#FG )F.$))9+;+;JH_H_+`aEOOE* )#4??e6F6F#FG!G.RDq5#3#33a!eu?O?O5OPQG! -G*.*B*B5*YZ*d'OO$7$UZO[ -18T"!sF4; F9 6F9c URn[UR5HupVURWXVR5nUR (a}[ U5=nboUHgn [UR"[R"X(R56[U Vs/sHo4UPM sn55n URU 5 Mi MUH'n URXbX5U 5n URXSSS9 M) M gs snf)zBuild an entanglement layer.NTFr)rrrrrrQrrrrrrrrrr) rUr.rrr rrxrrrrrs r/_build_entanglement_layer NLocal._build_entanglement_layerns  !$":":;HA 221a9I9IJM55%CE%JJ\W,G/$))9+;+;JH_H_+`aAAQ/ABEOOE* - -G*.*B*B5VW\c*d'OO$7$UZO[ -#<Bs!Dc US:XaURnURnOUR(ag[TU] 5 URS:XagUR(d [ UR SUR06nOUnUR(a)URURR5SSS9 [UR5nURUS5 [UR5HnUR (a/US:d[#UR$5S:aUR'5 UR)XU5 UR (a)[#UR*5S:aUR'5 UR-XU5 M UR.(dMUR0(a URS:aUR'5 UR)XUR5 URUS5 [3UR4[65(a[9UR45UlUR(d,UR=5nURCX@RDSS 9 gg![:a NJf=f![>a URA5nNHf=f) z(If not already built, build the circuit.Nrr%TFrr!r )r)#rr:rrrNr r_r%rTrriterrr&rirr=r)rArrr@rrIr rf global_phaserfloatrSto_gaterrjrgr)rUr.rrrxrWs r/r NLocal._builds >>   ??a  }}$djjAtyyAGG    OOD..335t%O P$112  %%g{;tyy!A$$!a%3t7M7M3NQR3R!  & &wA >$$T-B-B)Ca)G!  * *7 B" ..## A !  & &wDII F %%gz: g**,? @ @ ',W-A-A'B$ }} 1) KK{{K 7     1..0 1s$I)=I9) I65I69JJcg)zNIf certain blocks should use certain parameters this method can be overridden.Nr)rUreprxrs r/rPNLocal._parameter_generatorsr1)rQrCrDrMrEr?rFrNrKrLr=r<rGrHrArBr>r@rIrJrrrTrr_r) NNNNrFθTFFNnlocalN)rz int | NonerlQuantumCircuit | list[QuantumCircuit] | qiskit.circuit.Instruction | list[qiskit.circuit.Instruction] | Nonerr3rz"list[int] | list[list[int]] | NonerrRr rar!rr+zbool | list[list[Parameter]]r"rar#rarTQuantumCircuit | Noner% str | NonerVz bool | NonereturnNone)r6rR)rrRr6r7)r6ra)rVrar6r7)rmz typing.Anyr6r )r6zlist[QuantumCircuit])rwzGQuantumCircuit | list[QuantumCircuit] | Instruction | list[Instruction]r6r7)r6zstr | list[str] | list[list[str]] | list[int] | list[list[int]] | list[list[list[int]]] | list[list[list[list[int]]]] | Callable[[int], str] | Callable[[int], list[list[int]]])rzstr | list[str] | list[list[str]] | list[int] | list[list[int]] | list[list[list[int]]] | list[list[list[list[int]]]] | Callable[[int], str] | Callable[[int], list[list[int]]] | Noner6r7)T)rrar6ra)r6list[Parameter])rz!ParameterVector | list[Parameter]r6r7)r rar6r7)r6zset[int])rrRr6r7)r6r)r6zlist[float] | None)rrRrrRrrRr6zSequence[Sequence[int]])r6r )rTr r6r7)r6z list[tuple[float, float]] | None)rzlist[tuple[float, float]]r6r7)NF)rz+QuantumCircuit | qiskit.circuit.Instructionrz(list[int] | str | list[list[int]] | Nonerrar6z'NLocal')F)rzWMapping[Parameter, ParameterExpression | float] | Sequence[ParameterExpression | float]rrar6r4)NNNNN)r6r7)r/rRrxrRrz list[int]r6zParameter | None)%r __module__ __qualname____firstlineno____doc__rr;propertyrsetterrVrnrrrrrrr rrrrrrrTrrrrrrr&rrP__static_attributes__ __classcell__)rWs@r/r3r3 s&(TB( "&  ;? % $CG*/(-/3##5t/t/  t/ t/"9#t/$%t/&'t/()t/*%A+t/,$(-t/."&/t/0-1t/23t/45t/6 7t/  t/lGG A A## ^^  R:%% T] T  T T)) X] X  X  X" +""** * **0II!F((4.%% 4 4 "''R [[%%$ xKxK'*xK>AxK xKt##    BF <:<?< <  <F P dP  P PP>Z^"%\N\2J ?8Dr1r3c[U[5(a[UR5$URVs/sHn[U[ 5(dMUPM sn$s snf)a,Return the list of Parameters objects inside a circuit or instruction. This is required since, in a standard gate the parameters are not necessarily Parameter objects (e.g. U3Gate(0.1, 0.2, 0.3).params == [0.1, 0.2, 0.3]) and instructions and circuits do not have the same interface for parameters. )rfr rhrrr)rxps r/rrsH%((E$$%% <<NGet an entangler map for an arbitrary number of qubits. Args: num_block_qubits: The number of qubits of the entangling block. num_circuit_qubits: The number of qubits of the circuit. entanglement: The entanglement strategy. offset: The block offset, can be used if the entanglements differ per block. See mode ``sca`` for instance. Returns: The entangler map using mode ``entanglement`` to scatter a block of ``num_block_qubits`` qubits on ``num_circuit_qubits`` qubits. Raises: ValueError: If the entanglement mode ist not supported. z5Something went wrong in Rust space, here's the error:N)fast_entangler_map Exceptionr&)rnum_circuit_qubitsrrexcs r/rrs7&[!"4 ]] [PQWZZ[s  ) $)_StdlibGateResult)rrcXURS:wd[U5S:wagURSnUR(d[ UR 5[ UR 5:wd[ [RURR5SS5URRLd6[ URR5[ UR5:wag[URR[URR55$)Ngrr base_class)r*r)r-clbitsrrrO_STANDARD_GATE_MAPPINGget operationr%rJrrrH)rx instructions r/rr s S CJ!O**Q-K  ## $ell(; ; *..{/D/D/I/IJLZ^ _((33 4 &&-- .%8H8H2I I [22==s;CXCXC_C_?` aar1c N^^[T[5(aT/T-$[T5(aUU4Sj$[T5S:Xa//$[TSS[[ R 45(aT/m[T5T:wa[S[T5STS35e/nTHVn[U[5(aURU5 M+URUVs/sHn[U5PM sn5 MX U$![an[STS35UeSnAff=fs snf) zDIf the entanglement is Iterable[Iterable], normalize to list[tuple].c(>[T"U5T5$rd)r()rrnum_entanglement_blockss r/)_normalize_entanglement..+s5l66JLcdr1rzInvalid entanglement type: .NzNumber of block-entanglements (z,) must match number of entanglement blocks (z)!) rfrrr)rRrtrrSrrgr)rrRrG normalizedrx connectionss`` r/r(r(s7,$$~ 777 dd <At P l1oa(3 *> ? ?(>L  <33-c,.?-@A$$;#.ns!QLq*Q ":":Lr)rfrrr r&rOr)rrrfrom_standard_gaterY_get_gate_builder_trivial_builder from_callablerrg)rwr,r+rVrx is_standardnum_parametersbuilders r/r'r'Ls=&3n566J e^ , ,X   eS ! !+ #5eW!=>>#*EK t $ $8H$)O)[5<< A%" +"!QELL!QQ ,,U-A-ABE)*;E*B'*:5*A'''(8(8.RE% GJ r1c^U4SjnSU4$)Nc>>TR5nXR4$rd)rr)rcopiedrs r/rb!_trivial_builder..builders}}$$r1rr)rrbs` r/r^r^s% g:r1c^^[5nTRH2n[U[5(dMU[UR5-nM4 [ U5n[ U5mUU4SjnX44$)a.Construct a callable that handles parameter-rebinding. For a given gate, this return the number of free parameters and a callable that can be used to obtain a re-parameterized version of the gate. For example:: x, y = Parameter("x"), Parameter("y") gate = CUGate(x, 2 * y, 0.5, 0.) num_parameters, builder = _build_gate(gate) print(num_parameters) # prints 2 a, b = Parameter("a"), Parameter("b") new_gate, new_params = builder([a, b]) print(new_gate) # CUGate(a, 2 * b, 0.5, 0) print(new_params) # [a, 2 * b, 0.5, 0] c>TR5n[[TU55nTRR5n[ TR5HGupE[ U[ 5(dMURHnURXbU5nM XSU'MI X1lURbURRUSS9 X4$)NT)r) rrrrrrfrrassign _definitionr) new_parametersout param_dict bound_paramsrexpr parameterrsorted_parameterss r/rb"_get_gate_builder..buildersiik#/@A {{'')  -GA$ 344!%I;;yY2GHD"1"&Q . "  ?? & OO - -j$ - G  r1)rrrfrrr)_sort_parameters)rfree_parametersrBrarbrqs` @r/r]r]sb(eO [[ a, - - s1<<0 0O)N(9!(  ""r1cSn[XS9$)z!Sort a list of Parameter objects.c[U[5(a"URRUR4$UR4$rd)rfr vectorr%index)rps r/r_sort_parameters..keys8 i!7 8 8$$))9??; ;  r1)r)sorted)rrs r/rsrss! * &&r1)fullFr1TFFr2)rrRr!str | Gate | Iterable[str | Gate]rr}rrBlockEntanglement | Iterable[BlockEntanglement] | Callable[[int], BlockEntanglement | Iterable[BlockEntanglement]]rrRr rar!rr+rar"rar#rar%r5r6r )rxzQuantumCircuit | Instructionr6r8)r) rrRrFrRrrrrRr6zSequence[tuple[int, ...]])rxr r6z_StdlibGateResult | None)rr~rRrRr6zLlist[str | list[tuple[int]]] | Callable[[int], list[str | list[tuple[int]]]])rwr}r,zdict[str, Gate]r+rar6z list[Block])rrr6zLtuple[int, Callable[list[Parameter], tuple[Gate, list[ParameterValueType]]]])9r< __future__r collectionsrtypingcollections.abcrrrrrtqiskit.circuit.gaterqiskit.circuit.quantumcircuitr r qiskit.circuit.parametervectorr r qiskit.circuitr rrrrqiskit.exceptionsr%qiskit.circuit.library.standard_gatesrqiskit.utils.deprecationr"qiskit._accelerate.circuit_libraryrrrrDblueprintcircuitr TYPE_CHECKINGqiskitUnionrrRBlockEntanglementr0r3r namedtuplerHrLrr(r'r^r]rsrr1r/rs!" AA $LR* *P3 0 LLhx}&=!=> ! '+&+$)SS6S;S  K S SSS!%S $S"S S !SlO Od OVW[[/2[BE[OR[[4 **+>@VW79b*+ K+ ! +R+\0 -0$0!%0 0f Q1# 1#Q1#h'r1