z iSrSSKJr SSKJrJr SSKJr SSKJ r SSK J r J r SSK Jr SSKJr \(a SS KJr SS KJr "S S 5r\"S S55rg)z A two-ways dict to represent a layout. Layout is the relation between virtual (qu)bits and physical (qu)bits. Virtual (qu)bits are tuples, e.g. `(QuantumRegister(3, 'qr'), 2)` or simply `qr[2]`. Physical (qu)bits are integers. ) annotations)List TYPE_CHECKING) dataclass)circuit)QubitQuantumRegister) LayoutError isinstanceint) DAGCircuit) PropertySetc\rSrSrSrSrS SjrSrSr\ S5r S r S r S r S rS rSrSrSrS SjrSrSrSrSrSrSrS!Sjr\ S5r\ S5r\ S5rS"SjrS#SjrS$Sjr Sr!g)%Layout#z$Two-ways dict to represent a Layout.)_regs_p2v_v2pNc/Ul0Ul0UlUb2[U[5(d [ S5eUR U5 gg)zYconstruct a Layout from a bijective dictionary, mapping virtual qubits to physical qubitsNzLayout constructor takes a dict)rrr isinstancedictr from_dict)self input_dicts R/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/transpiler/layout.py__init__Layout.__init__(sI    !j$//!"CDD NN: & "c/nURR5Hup#URUSUS35 M U(a USSSUS'SSRU5-S-$)zRepresentation of a Layoutz: ,Nz Layout({  z }))ritemsappendjoin)rstr_listkeyvals r__repr__Layout.__repr__3sg )HC OOse2cU!, -* #B<,HRLdii11F::rcUR5H=up#[RX#5upEX@RU'UcM/XPRU'M? g)a<Populates a Layout from a dictionary. The dictionary must be a bijective mapping between virtual qubits (tuple) and physical qubits (int). Args: input_dict (dict): e.g.:: {(QuantumRegister(3, 'qr'), 0): 0, (QuantumRegister(3, 'qr'), 1): 1, (QuantumRegister(3, 'qr'), 2): 2} Can be written more concisely as follows: * virtual to physical:: {qr[0]: 0, qr[1]: 1, qr[2]: 2} * physical to virtual:: {0: qr[0], 1: qr[1], 2: qr[2]} N)r#rorder_based_on_typerr)rrr'valuevirtualphysicals rrLayout.from_dict<sL8%**,JC & : :3 F G")IIh !)IIg  -rcJ[U5(a0[U[[S545(a[ U5nUnX24$[U5(a0[U[[S545(a[ U5nUnX24$[ S[U5S[U5S35e)zTdecides which one is physical/virtual based on the type. Returns (virtual, physical)Nz The map (z -> z7) has to be a (Bit -> integer) or the other way around.)r rrtypeintr )value1value2r/r.s rr,Layout.order_based_on_type_s  ZT 8K%L%L6{HG  6 " "z&5$t*:M'N'N6{HG   DL>d6l^<,, rcXR;aURU$XR;aURU$[SUS35e)Nz The item z does not exist in the Layout)rrKeyErrorritems r __getitem__Layout.__getitem__osG 99 99T? " 99 99T? "4&(EFGGrcHXR;=(d XR;$N)rrr9s r __contains__Layout.__contains__vsyy 5DII$55rcT[RX5up4URX45 gr>)rr,_set_type_checked_item)rr'r-r.r/s r __setitem__Layout.__setitem__ys#"66sB ##G6rc$URRUS5nURRUS5 URRUS5nURRUS5 XRU'UbX RU'ggr>)rpopr)rr.r/olds rrBLayout._set_type_checked_item}sqiimmGT* c4 iimmHd+ c4 % (  !)IIg  rc&[U[5(a(URURU URU g[U[5(a(URURU URU g[ S[ U5S35e)Nz>The key to remove should be of the form Qubit or integer) and z was provided)rr3rrrr r2)rr's r __delitem__Layout.__delitem__s} c3   $))C.) # U # # $))C.) #**.s)MC rc,[UR5$r>)lenrrs r__len__Layout.__len__s499~rc[U[5(a9URUR:H=(a URUR:H$g)NF)rrrr)rothers r__eq__ Layout.__eq__s7 eV $ $99 *FtyyEJJ/F Frc[U5"5nURR5UlURR5UlURR5UlU$)z$Returns a copy of a Layout instance.)r2rcopyrr)r layout_copys rrV Layout.copysL4jl  JJOO- 99>>+ 99>>+ rcUc[[UR5S:XaSnO?[UR5n[U5HnX@R;dMUn O US-nX U'g)a Adds a map element between `bit` and `physical_bit`. If `physical_bit` is not defined, `bit` will be mapped to a new physical bit. Args: virtual_bit (tuple): A (qu)bit. For example, (QuantumRegister(3, 'qr'), 2). physical_bit (int): A physical bit. For example, 3. Nr)rMrmaxrange)r virtual_bit physical_bit max_physicalphysical_candidates radd Layout.addsb  499~" "499~ */ *=&):'9 +> $0!#3L([rc|URRU5 UHnX ;dM URU5 M g)zAdds at the end physical_qubits that map each bit in reg. Args: reg (Register): A (qu)bit Register. For example, QuantumRegister(3, 'qr'). N)rr$ra)rregbits r add_registerLayout.add_registers0 #C rc,[UR5$)z Returns the registers in the layout [QuantumRegister(2, 'qr0'), QuantumRegister(3, 'qr1')] Returns: Set: A set of Registers in the layout )setrrNs r get_registersLayout.get_registerss 4::rcUR$)zb Returns the dictionary where the keys are virtual (qu)bits and the values are physical (qu)bits. )rrNs rget_virtual_bitsLayout.get_virtual_bits yyrcUR$)zb Returns the dictionary where the keys are physical (qu)bits and the values are virtual (qu)bits. )rrNs rget_physical_bitsLayout.get_physical_bitsrorcd[U5[U5La [S5eXnXX'X0U'g)zSwaps the map between left and right. Args: left (tuple or int): Item to swap with right. right (tuple or int): Item to swap with left. Raises: LayoutError: If left and right have not the same type. z:The method swap only works with elements of the same type.N)r2r )rleftrighttemps rswap Layout.swaps7 :T%[ (Z[ [z[ U rc0nURR5H%up4XAR;a [S5eXX#'M' U$)aCombines self and another_layout into an "edge map". For example:: self another_layout resulting edge map qr_1 -> 0 0 <- q_2 qr_1 -> q_2 qr_2 -> 2 2 <- q_1 qr_2 -> q_1 qr_3 -> 3 3 <- q_0 qr_3 -> q_0 The edge map is used to compose dags via, for example, compose. Args: another_layout (Layout): The other layout to combine. Returns: dict: A "edge map". Raises: LayoutError: another_layout can be bigger than self, but not smaller. Otherwise, raises. zfThe wire_map_from_layouts() method does not support when the other layout (another_layout) is smaller.)rr#rr )ranother_layoutedge_mapr.r/s rcombine_into_edge_mapLayout.combine_into_edge_mapsT(!%!2 G222!A!/ 8H  "3rc\S/[U5-n[U5H up4XnXRU'M U$)zGiven an ordered list of bits, reorder them according to this layout. The list of bits must exactly match the virtual bits in this layout. Args: bits (list[Bit]): the bits to reorder. Returns: List: ordered bits. r)rM enumerate)rbitsorderivjs r reorder_bitsLayout.reorder_bitss:c$idODAA!H$ rc[5nUH<n[U[5(aURU5 M+UR U5 M> U$)zCreates a trivial ("one-to-one") Layout with the registers and qubits in `regs`. Args: *regs (Registers, Qubits): registers and qubits to include in the layout. Returns: Layout: A layout with all the `regs` in the given order. )rrr rfra)regslayoutrds rgenerate_trivial_layoutLayout.generate_trivial_layout#sBC#//##C( 3   rc [SU55(d [S5e[U5[[U55:wa [S5e[ SU55n[U5U:wa[S[U5SUSUS35e[ 5nS nUH>n[ UR5HnXX5U'US - nM URU5 M@ U[U5:waXS HnS X7'M U$) acConverts a list of integers to a Layout mapping virtual qubits (index of the list) to physical qubits (the list values). Args: int_list (list): A list of integers. *qregs (QuantumRegisters): The quantum registers to apply the layout to. Returns: Layout: The corresponding Layout object. Raises: LayoutError: Invalid input layout. c38# UHn[U5v M g7fr>r ).0rs r &Layout.from_intlist..Cs6X=##XzExpected a list of ints4Duplicate values not permitted; Layout is bijective.c38# UHoRv M g7fr>)size)rrds rrrGs3UcUrzInteger list length (z*) must equal number of qubits in circuit (z): .rrZN) allr rMrisumrr\rrf)int_listqregs num_qubitsoutmain_idxqregidxint_items r from_intlistLayout.from_intlist4s6X66678 8 x=CH . .TU U3U33 x=J &'H 7)l#hZq: hDTYY'!)!3IA (   T "  s8} $$Y/ $ 0 rc[5n[U5HHup4UcM [U[5(a XBR;a [ S5eX2U'M?[ S5e UHnUR U5 M U$)a[ Populates a Layout from a list containing virtual qubits, Qubit or None. Args: qubit_list (list): e.g.: [qr[0], None, qr[2], qr[3]] *qregs (QuantumRegisters): The quantum registers to apply the layout to. Returns: Layout: the corresponding Layout object Raises: LayoutError: If the elements are not Qubit or None rz9The list should contain elements of the Bits or NoneTypes)rrrrrr rf) qubit_listrrr/r.rs rfrom_qubit_listLayout.from_qubit_listZsz h!*:!6 H'5))hh&%&\]]'G !"]^^"7D   T " rc UR5n[URR5VVs0sH upEXCX%_M snn5$s snnf)aCompose this layout with another layout. If this layout represents a mapping from the P-qubits to the positions of the Q-qubits, and the other layout represents a mapping from the Q-qubits to the positions of the R-qubits, then the composed layout represents a mapping from the P-qubits to the positions of the R-qubits. Args: other: The existing :class:`.Layout` to compose this :class:`.Layout` with. qubits: A list of :class:`.Qubit` objects over which ``other`` is defined, used to establish the correspondence between the positions of the ``other`` qubits and the actual qubits. Returns: A new layout object the represents this layout composed with the ``other`` layout. )rmrrr#)rrRqubits other_v2pvirtphyss rcomposeLayout.composexsH"**, tyyGXYGXtv|44GXYZZYsA c [U5VVs0sHup4XC_M nnn[URR5VVs0sH upgX'XV_M snn5$s snnfs snnf)aFinds the inverse of this layout. This is possible when the layout is a bijective mapping, however the input and the output qubits may be different (in particular, this layout may be the mapping from the extended-with-ancillas virtual qubits to physical qubits). Thus, if this layout represents a mapping from the P-qubits to the positions of the Q-qubits, the inverse layout represents a mapping from the Q-qubits to the positions of the P-qubits. Args: source_qubits: A list of :class:`.Qubit` objects representing the domain of the layout. target_qubits: A list of :class:`.Qubit` objects representing the image of the layout. Returns: A new layout object the represents the inverse of this layout. )rrrr#)r source_qubits target_qubitspqsource_qubit_to_positionrpos_physs rinverseLayout.inversesr&6?}5M#N5MTQAD5M #N'+iioo&7 &7ND')A)GG&7   $O s AA# crS/[U5-n[U5Hup4URUnX2U'M U$)aCreates a permutation corresponding to this layout. This is possible when the layout is a bijective mapping with the same source and target qubits (for instance, a "final_layout" corresponds to a permutation of the physical circuit qubits). If this layout is a mapping from qubits to their new positions, the resulting permutation describes which qubits occupy the positions 0, 1, 2, etc. after applying the permutation. For example, suppose that the list of qubits is ``[qr_0, qr_1, qr_2]``, and the layout maps ``qr_0`` to ``2``, ``qr_1`` to ``0``, and ``qr_2`` to ``1``. In terms of positions in ``qubits``, this maps ``0`` to ``2``, ``1`` to ``0`` and ``2`` to ``1``, with the corresponding permutation being ``[1, 2, 0]``. N)rMrr)rrpermrrposs rto_permutationLayout.to_permutations@"vF #f%DA))A,CI& r)rrrr>)returnz list[int])rRrr List[Qubit]rr)rrrr)rr)"__name__ __module__ __qualname____firstlineno____doc__ __slots__rr)r staticmethodr,r;r?rCrBrJrOrSrVrarfrjrmrqrwr|rrrrrrr__static_attributes__rrrr#s.)I ';!*F ! !H67*  )2  @( ##J:[( 6rrc\rSrSr%SrS\S'S\S'SrS\S 'SrS \S 'SrS \S 'SSSjjr SSSjjr SSjr SSSjjr SSSjjr \SSj5rSSjrSrg)TranspileLayoutia+Layout attributes for the output circuit from transpiler. The :mod:`~qiskit.transpiler` is unitary-preserving up to the "initial layout" and "final layout" permutations. The initial layout permutation is caused by setting and applying the initial layout during the :ref:`transpiler-preset-stage-layout`. The final layout permutation is caused by :class:`~.SwapGate` insertion during the :ref:`transpiler-preset-stage-routing`. This class provides an interface to reason about these permutations using a variety of helper methods. During the layout stage, the transpiler can potentially remap the order of the qubits in the circuit as it fits the circuit to the target backend. For example, let the input circuit be: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: from qiskit.circuit import QuantumCircuit, QuantumRegister qr = QuantumRegister(3, name="MyReg") qc = QuantumCircuit(qr) qc.h(0) qc.cx(0, 1) qc.cx(0, 2) qc.draw("mpl") Suppose that during the layout stage the transpiler reorders the qubits to be: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: from qiskit import QuantumCircuit qc = QuantumCircuit(3) qc.h(2) qc.cx(2, 1) qc.cx(2, 0) qc.draw("mpl") Then the output of the :meth:`.initial_virtual_layout` method is equivalent to:: Layout({ qr[0]: 2, qr[1]: 1, qr[2]: 0, }) (it is also this attribute in the :meth:`.QuantumCircuit.draw` and :func:`.circuit_drawer` which is used to display the mapping of qubits to positions in circuit visualizations post-transpilation). Building on the above example, suppose that during the routing stage the transpiler needs to insert swap gates, and the output circuit becomes: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: from qiskit import QuantumCircuit qc = QuantumCircuit(3) qc.h(2) qc.cx(2, 1) qc.swap(0, 1) qc.cx(2, 1) qc.draw("mpl") Then the output of the :meth:`routing_permutation` method is:: [1, 0, 2] which maps positions of qubits before routing to their final positions after routing. There are three public attributes associated with the class, however these are mostly provided for backwards compatibility and represent the internal state from the transpiler. They are defined as: * :attr:`initial_layout` - This attribute is used to model the permutation caused by the :ref:`transpiler-preset-stage-layout`. It is a :class:`~.Layout` object that maps the input :class:`~.QuantumCircuit`\s :class:`~.circuit.Qubit` objects to the position in the output :class:`.QuantumCircuit.qubits` list. * :attr:`input_qubit_mapping` - This attribute is used to retain input ordering of the original :class:`~.QuantumCircuit` object. It maps the virtual :class:`~.circuit.Qubit` object from the original circuit (and :attr:`initial_layout`) to its corresponding position in :attr:`.QuantumCircuit.qubits` in the original circuit. This is needed when computing the permutation of the :class:`Operator` of the circuit (and used by :meth:`.Operator.from_circuit`). * :attr:`final_layout` - This attribute is used to model the permutation caused by the :ref:`transpiler-preset-stage-routing`. It is a :class:`~.Layout` object that maps the output circuit's qubits from :class:`.QuantumCircuit.qubits` in the output circuit to their final positions after routing. Importantly, this only represents the permutation caused by inserting :class:`~.SwapGate`\s into the :class:`~.QuantumCircuit` during the :ref:`transpiler-preset-stage-routing`. It is **not** a mapping from the original input circuit's position to the final position at the end of the transpiled circuit. If you need this, you can use the :meth:`.final_index_layout` to generate this. If :attr:`final_layout` is set to ``None``, this indicates that routing was not run, and can be considered equivalent to a trivial layout with the qubits from the output circuit's :attr:`~.QuantumCircuit.qubits` list. rinitial_layoutzdict[circuit.Qubit, int]input_qubit_mappingNz Layout | None final_layoutz int | None_input_qubit_countzList[Qubit] | None_output_qubit_listcU(d UR$[URR5R5VVs0sH&up#URUUR :dM$X#_M( snn5$s snnf)axReturn a :class:`.Layout` object for the initial layout. This returns a mapping of virtual :class:`~.circuit.Qubit` objects in the input circuit to the positions of the physical qubits selected during layout. This is analogous to the :attr:`.initial_layout` attribute. Args: filter_ancillas: If set to ``True`` only qubits in the input circuit will be in the returned layout. Any ancilla qubits added to the output circuit will be filtered from the returned object. Returns: A layout object mapping the input circuit's :class:`~.circuit.Qubit` objects to the positions of the selected physical qubits. )rrrmr#rr)rfilter_ancillaskrs rinitial_virtual_layout&TranspileLayout.initial_virtual_layout4sy&& &!//@@BHHJ JDA++A.1H1HHJ    s #A9 +A9 cURR5nU(aS/UR-nOS/[U5-nUR 5H0upEUR UnU(aX`R:aM,XSU'M2 U$)a'Generate an initial layout as an array of integers. Args: filter_ancillas: If set to ``True`` any ancilla qubits added to the transpiler will not be included in the output. Return: A layout array that maps a position in the array to its new position in the output circuit. N)rrmrrMr#r)rr virtual_mapoutputrrrs rinitial_index_layout$TranspileLayout.initial_index_layoutMs))::< Vd555FVc+..F%++-JD**40C3*A*A#A3K .  rcURc'[[[UR555$URR 5nURVs/sHo!UPM sn$s snf)aGenerate a final layout as an array of integers. If there is no :attr:`.final_layout` attribute present then that indicates there was no output permutation caused by routing or other transpiler transforms. In this case the function will return a list of ``[0, 1, 2, .., n]``. Returns: A layout array that maps a position in the array to its new position in the output circuit. )rlistr\rMrrm)rrrs rrouting_permutation#TranspileLayout.routing_permutationesb    $c$"9"9:;< <''88: .2.E.EF.EdD!.EFFFsA.c URcJ[URVs/sH(n[USS5R S5(dM&UPM* sn5nO URnUR c$[ URR55nO UR nURR5VVs0sHupVXe_M nnn/nU(aUn O[UR 5n [U 5HCn URXzn URbURXKn URU 5 ME U$s snfs snnf)aZGenerate the final layout as an array of integers. This method will generate an array of final positions for each qubit in the input circuit. For example, if you had an input circuit like:: qc = QuantumCircuit(3) qc.h(0) qc.cx(0, 1) qc.cx(0, 2) and the output from the transpiler was:: tqc = QuantumCircuit(3) tqc.h(2) tqc.cx(2, 1) tqc.swap(0, 1) tqc.cx(2, 1) then the :meth:`.final_index_layout` method returns:: [2, 0, 1] This can be seen as follows. Qubit 0 in the original circuit is mapped to qubit 2 in the output circuit during the layout stage, which is mapped to qubit 2 during the routing stage. Qubit 1 in the original circuit is mapped to qubit 1 in the output circuit during the layout stage, which is mapped to qubit 0 during the routing stage. Qubit 2 in the original circuit is mapped to qubit 0 in the output circuit during the layout stage, which is mapped to qubit 1 during the routing stage. The output list length will be as wide as the input circuit's number of qubits, as the output list from this method is for tracking the permutation of qubits in the original circuit caused by the transpiler. Args: filter_ancillas: If set to ``False`` any ancillas allocated in the output circuit will be included in the layout. Returns: A list of final positions for each input circuit qubit. _registerancilla) rrMrgetattr startswithrrrrmr#r\rr$) rrxnum_source_qubitscircuit_qubitsrr pos_to_virt qubit_indicesrindex qubit_idxs rfinal_index_layout"TranspileLayout.final_index_layoutus>P  " " *!$"555q+r2==iH5! !% 7 7   " " *!$"3"3"D"D"FGN!44N(,(@(@(F(F(HI(Hqt(H I *JT445J:&E++K,>?I  , --n.GH   + ' 1Js%E E>E cURUS9nURR5VVs0sHup4XC_M nnn[[ U5VVs0sH upgXVU_M snn5$s snnfs snnf)aGenerate the final layout as a :class:`.Layout` object. This method will generate an array of final positions for each qubit in the input circuit. For example, if you had an input circuit like:: qc = QuantumCircuit(3) qc.h(0) qc.cx(0, 1) qc.cx(0, 2) and the output from the transpiler was:: tqc = QuantumCircuit(3) tqc.h(2) tqc.cx(2, 1) tqc.swap(0, 1) tqc.cx(2, 1) then the return from this function would be a layout object:: Layout({ qc.qubits[0]: 2, qc.qubits[1]: 0, qc.qubits[2]: 1, }) This can be seen as follows. Qubit 0 in the original circuit is mapped to qubit 2 in the output circuit during the layout stage, which is mapped to qubit 2 during the routing stage. Qubit 1 in the original circuit is mapped to qubit 1 in the output circuit during the layout stage, which is mapped to qubit 0 during the routing stage. Qubit 2 in the original circuit is mapped to qubit 0 in the output circuit during the layout stage, which is mapped to qubit 1 during the routing stage. The output list length will be as wide as the input circuit's number of qubits, as the output list from this method is for tracking the permutation of qubits in the original circuit caused by the transpiler. Args: filter_ancillas: If set to ``False`` any ancillas allocated in the output circuit will be included in the layout. Returns: A layout object mapping to the final positions for each qubit. )r)rrr#rr)rrresrrrrrs rfinal_virtual_layout$TranspileLayout.final_virtual_layoutsrX%%o%F(,(@(@(F(F(HI(Hqt(H I9S>R>KE{)4/>RSSJRs A*A0 c D^^^USmUSnUSmUSnUSn[UR5nTcUcUcgTbUc U"TTX5U5$Tc'[[[ UR555mUc [T5nUc'[[[ UR555n[ TTR S9m[UR5nTSUVs/sHnXHPM n nU[U 5:a$U R[[U 5U55 S UU4Sjjn S UU4S jjn [U5V s/sHn U "X"U 55PM n n [U5V s/sHoRX<5RPM! nn [U5V s/sH n XU PM nn [[ U5VVs0sHunnUURU_M snn5nU"TTX5[UR55$s snfs sn fs sn fs sn fs snnf) a Construct the :class:`TranspileLayout` by reading out the fields from the given :class:`.PropertySet`. Returns ``None`` if there are no layout-setting keys present. This includes combining the different keys of the property set into the full set of initial and final layouts, including virtual permutations. This does not invalidate or in any way mutate the given property set. In order to "canonicalize" the property set afterwards, call :meth:`write_into_property_set`. This reads the following property-set keys: ``layout`` **Required**. The :class:`.Layout` object mapping virtual qubits (potentially expanded with ancillas) to physical-qubit indices. This corresponds directly to :attr:`initial_layout`. .. note:: In all standard use, this is a required field. However, if ``virtual_permutation_layout`` is set, then a "trivial" layout will be inferred, even if the circuit is not actually laid out to hardware. This is an unfortunate limitation of this class's data model, where it is not possible to specify a final permutation without also having an initial layout. This deficiency will be corrected in Qiskit 3.0. ``original_qubit_indices`` **Required** (but automatically set by the :class:`.PassManager`). The mapping ``{virtual: index}`` that indicates which relative index each incoming virtual qubit was, in the input circuit. This can be expanded with ancillas too (in which case the ancilla indices don't mean much, since they weren't in the incoming circuit). ``num_input_qubits`` **Required** (but automatically set by the :class:`.PassManager`). The number of explicit virtual qubits in the input circuit (i.e. not including implicit ancillas). ``final_layout`` **Optional**. The effective final permutation, in terms of the current qubits of the :class:`.DAGCircuit`. This corresponds directly to :attr:`final_layout`. ``virtual_permutation_layout`` **Optional**. This is set by certain optimization passes that run before layout selection, such as :class:`.ElidePermutations`. It is similar in spirit to ``final_layout``, but typically only applies to the input virtual qubits. .. warning:: This object uses the opposite permutation convention to ``final_layout`` due to an oversight in Qiskit during its introduction. In other words, ``virtual_permutation_layout`` maps a :class:`.Qubit` instance at the end of the circuit to its integer index at the start of the circuit. Args: dag: the current state of the :class:`.DAGCircuit`. property_set: the current transpiler's property set. This must at least have the ``layout`` key set. rroriginal_qubit_indicesvirtual_permutation_layoutnum_input_qubitsN)r'c>TTU$r>r) virtual_indexr input_qubitss rrelabel_virtual_to_physicalFTranspileLayout.from_property_set..relabel_virtual_to_physicalws!,}"=> >rc>TTU$r>r)physical_indexrinput_qubit_indicess rrelabel_physical_to_virtualFTranspileLayout.from_property_set..relabel_physical_to_virtualzs&~n'EF Fr)rr3)rr3) rrrrrsortedgetrMextendr\find_bitr)clsdag property_setrrr output_qubitsrr]undo_elided_on_virtualsrrrundo_elided_on_physicalsundo_routing_on_physicalsundo_total_on_physicals qubit_index is_set_torrrs @@@rfrom_property_set!TranspileLayout.from_property_setst&h/#N3 *+CD%12N%O"'(:;SZZ(  !&@&H\Ma  %*D*L 3\Ub   !#D3::)>$?@N % -)/0C)D &  !$y'<"=>L17J7N7NO _ \ ,,=-=># >  ' 3> # 34 4 # * *55L1Mz+Z [ ? ? G G#( "3 $ #4 ('(CN(ST #4 !$ TYYcSd% SdLL5 6 < rsV#&!14+,-YYx  OGOG OGr