gdZddlmZddlZddlZddlmZmZmZddl m Z ddl Z ddl Z ddl Z ddlZddlZddlmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZm Z dd l!m"Z"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8m9Z9ddl:m;Z;mZ?GddeZ@GddeZAe jBeAe8ddd d#d"ZCdS)$z_ A target object represents the minimum set of information the transpiler needs from a backend ) annotationsN)OptionalListAny)Mapping) BaseTargetBaseInstructionProperties) Parameter)ParameterValueType)Gate)get_standard_gate_name_mapping)InstructionScheduleMap)CalibrationEntry ScheduleDef)Schedule ScheduleBlock) CouplingMap)TranspilerError)InstructionDurations)TimingConstraints)BackendPropertyError) PulseErrorUnassignedDurationError) QiskitError)QubitProperties)BackendProperties)deprecate_func deprecate_arg)deprecate_pulse_dependencydeprecate_pulse_argc@eZdZdZdgZ dfd Zedd ddfd Zee d dZ e j e d ddZ edZ e j ddZ dZ dfd Zdfd ZxZS) InstructionPropertiesaA representation of the properties of a gate implementation. This class provides the optional properties that a backend can provide about an instruction. These represent the set that the transpiler can currently work with if present. However, if your backend provides additional properties for instructions you should subclass this to add additional custom attributes for those custom/additional properties by the backend. _calibrationNcXtt||||SN)superr"__new__)clsdurationerrorargskwargs __class__s N/granary/edev/quantum/lib/python3.11/site-packages/qiskit/transpiler/target.pyr'zInstructionProperties.__new__Ps/*C0088 5   calibrationc |duSr%)calss r.zInstructionProperties.[s t4?Or/) predicater) float | Noner*2Schedule | ScheduleBlock | CalibrationEntry | Nonecdtd|_||_dS)awCreate a new ``InstructionProperties`` object Args: duration: The duration, in seconds, of the instruction on the specified set of qubits error: The average error rate for the instruction on the specified set of qubits. calibration: DEPRECATED. The pulse representation of the instruction. N)r&__init__r#_calibration_prop)selfr)r*r0r-s r.r9zInstructionProperties.__init__[s1 59!,r/T) is_propertyc|jS)a?The pulse representation of the instruction. .. note:: This attribute always returns a Qiskit pulse program, but it is internally wrapped by the :class:`.CalibrationEntry` to manage unbound parameters and to uniformly handle different data representation, for example, un-parsed Pulse Qobj JSON that a backend provider may provide. This value can be overridden through the property setter in following manner. When you set either :class:`.Schedule` or :class:`.ScheduleBlock` this is always treated as a user-defined (custom) calibration and the transpiler may automatically attach the calibration data to the output circuit. This calibration data may appear in the wire format as an inline calibration, which may further update the backend standard instruction set architecture. If you are a backend provider who provides a default calibration data that is not needed to be attached to the transpiled quantum circuit, you can directly set :class:`.CalibrationEntry` instance to this attribute, in which you should set :code:`user_provided=False` when you define calibration data for the entry. End users can still intentionally utilize the calibration data, for example, to run pulse-level simulation of the circuit. However, such entry doesn't appear in the wire format, and backend must use own definition to compile the circuit down to the execution format. r:r;s r.r0z!InstructionProperties.calibrationos :%%r/+Schedule | ScheduleBlock | CalibrationEntryc||_dSr%r>)r;r0s r.r0z!InstructionProperties.calibrations"-r/c|jdStj5tjdt|jcdddS#1swxYwYdS)Nignoreactioncategory)r#warningscatch_warnings simplefilterDeprecationWarning get_scheduler?s r.r:z'InstructionProperties._calibration_props   $4  $ & & 4 4  !@QRRr/statect|d|d|_|d|_dS)Nr)r& __setstate__r:r#r;rYr-s r.r]z"InstructionProperties.__setstate__s= U1X&&&!&q!!Hr/NN)NNN)r)r6r*r6r0r7)r0r@)rTrUrYrU)__name__ __module__ __qualname____doc__ __slots__r'r r9propertyrr0setterr:rSrWr] __classcell__r-s@r.r"r"Bs I        2O2OPPP"&"JN ------QP-&D111&&21X&:D111---21-44X4&&&&   SSSSSS%%%%%%%%%%r/r"c eZdZdZdZ dYdZfd Z dYdZd[fd ZfdZe d[dZ dZ dZ dZ e dZdZe d\d]d%Z d\d]d&Ze dd'd^d,Zdd'd^d-Zed.Zed/Zd0Zd1Zd_d3Zd4Zd5Zd6Zd\d7Zd8Zd9Zd:Z d;Z!d<Z"d=Z#d`fd? Z$dafdB Z%e&e'dCe(dDdEdFdGdHI dbdcdXZ)xZ*S)dTargeta3 The intent of the ``Target`` object is to inform Qiskit's compiler about the constraints of a particular backend so the compiler can compile an input circuit to something that works and is optimized for a device. It currently contains a description of instructions on a backend and their properties as well as some timing information. However, this exact interface may evolve over time as the needs of the compiler change. These changes will be done in a backwards compatible and controlled manner when they are made (either through versioning, subclassing, or mixins) to add on to the set of information exposed by a target. As a basic example, let's assume backend has two qubits, supports :class:`~qiskit.circuit.library.UGate` on both qubits and :class:`~qiskit.circuit.library.CXGate` in both directions. To model this you would create the target like:: from qiskit.transpiler import Target, InstructionProperties from qiskit.circuit.library import UGate, CXGate from qiskit.circuit import Parameter gmap = Target() theta = Parameter('theta') phi = Parameter('phi') lam = Parameter('lambda') u_props = { (0,): InstructionProperties(duration=5.23e-8, error=0.00038115), (1,): InstructionProperties(duration=4.52e-8, error=0.00032115), } gmap.add_instruction(UGate(theta, phi, lam), u_props) cx_props = { (0,1): InstructionProperties(duration=5.23e-7, error=0.00098115), (1,0): InstructionProperties(duration=4.52e-7, error=0.00132115), } gmap.add_instruction(CXGate(), cx_props) Each instruction in the ``Target`` is indexed by a unique string name that uniquely identifies that instance of an :class:`~qiskit.circuit.Instruction` object in the Target. There is a 1:1 mapping between a name and an :class:`~qiskit.circuit.Instruction` instance in the target and each name must be unique. By default, the name is the :attr:`~qiskit.circuit.Instruction.name` attribute of the instruction, but can be set to anything. This lets a single target have multiple instances of the same instruction class with different parameters. For example, if a backend target has two instances of an :class:`~qiskit.circuit.library.RXGate` one is parameterized over any theta while the other is tuned up for a theta of pi/6 you can add these by doing something like:: import math from qiskit.transpiler import Target, InstructionProperties from qiskit.circuit.library import RXGate from qiskit.circuit import Parameter target = Target() theta = Parameter('theta') rx_props = { (0,): InstructionProperties(duration=5.23e-8, error=0.00038115), } target.add_instruction(RXGate(theta), rx_props) rx_30_props = { (0,): InstructionProperties(duration=1.74e-6, error=.00012) } target.add_instruction(RXGate(math.pi / 6), rx_30_props, name='rx_30') Then in the ``target`` object accessing by ``rx_30`` will get the fixed angle :class:`~qiskit.circuit.library.RXGate` while ``rx`` will get the parameterized :class:`~qiskit.circuit.library.RXGate`. .. note:: This class assumes that qubit indices start at 0 and are a contiguous set if you want a submapping the bits will need to be reindexed in a new``Target`` object. .. note:: This class only supports additions of gates, qargs, and qubits. If you need to remove one of these the best option is to iterate over an existing object and create a new subset (or use one of the methods to do this). The object internally caches different views and these would potentially be invalidated by removals.  _gate_map_coupling_graph_instruction_durations_instruction_schedule_mapNrr[ description str | None num_qubitsintdtr6 granularity min_lengthpulse_alignmentacquire_alignmentqubit_properties list | Noneconcurrent_measurementsc |t|}tt||||||||||| S)a Create a new ``Target`` object Args: description (str): An optional string to describe the Target. num_qubits (int): An optional int to specify the number of qubits the backend target has. If not set it will be implicitly set based on the qargs when :meth:`~qiskit.Target.add_instruction` is called. Note this must be set if the backend target is for a noiseless simulator that doesn't have constraints on the instructions so the transpiler knows how many qubits are available. dt (float): The system time resolution of input signals in seconds granularity (int): An integer value representing minimum pulse gate resolution in units of ``dt``. A user-defined pulse gate should have duration of a multiple of this granularity value. min_length (int): An integer value representing minimum pulse gate length in units of ``dt``. A user-defined pulse gate should be longer than this length. pulse_alignment (int): An integer value representing a time resolution of gate instruction starting time. Gate instruction should start at time which is a multiple of the alignment value. acquire_alignment (int): An integer value representing a time resolution of measure instruction starting time. Measure instruction should start at time which is a multiple of the alignment value. qubit_properties (list): A list of :class:`~.QubitProperties` objects defining the characteristics of each qubit on the target device. If specified the length of this list must match the number of qubits in the target, where the index in the list matches the qubit number the properties are defined for. If some qubits don't have properties available you can set that entry to ``None`` concurrent_measurements(list): A list of sets of qubits that must be measured together. This must be provided as a nested list like ``[[0, 1], [2, 3, 4]]``. Raises: ValueError: If both ``num_qubits`` and ``qubit_properties`` are both defined and the value of ``num_qubits`` differs from the length of ``qubit_properties``. )strr&rkr') r(rqrsrurvrwrxryrzr|r+r,r-s r.r'zTarget.__new__sYp  "k**KVS!!))          #   r/c >i|_d|_d|_d|_dSr%rl) r;rqrsrurvrwrxryrzr|s r.r9zTarget.__init__Vs)#&*#)-&&&r/c\tj|}|s |p|j}n$|std|td|}||rddi}||jvrt d|dt |||||j|<d|_d|_ d|_ dS)aAdd a new instruction to the :class:`~qiskit.transpiler.Target` As ``Target`` objects are strictly additive this is the primary method for modifying a ``Target``. Typically, you will use this to fully populate a ``Target`` before using it in :class:`~qiskit.providers.BackendV2`. For example:: from qiskit.circuit.library import CXGate from qiskit.transpiler import Target, InstructionProperties target = Target() cx_properties = { (0, 1): None, (1, 0): None, (0, 2): None, (2, 0): None, (0, 3): None, (2, 3): None, (3, 0): None, (3, 2): None } target.add_instruction(CXGate(), cx_properties) Will add a :class:`~qiskit.circuit.library.CXGate` to the target with no properties (duration, error, etc) with the coupling edge list: ``(0, 1), (1, 0), (0, 2), (2, 0), (0, 3), (2, 3), (3, 0), (3, 2)``. If there are properties available for the instruction you can replace the ``None`` value in the properties dictionary with an :class:`~qiskit.transpiler.InstructionProperties` object. This pattern is repeated for each :class:`~qiskit.circuit.Instruction` the target supports. Args: instruction (Union[qiskit.circuit.Instruction, Type[qiskit.circuit.Instruction]]): The operation object to add to the map. If it's parameterized any value of the parameter can be set. Optionally for variable width instructions (such as control flow operations such as :class:`~.ForLoop` or :class:`~MCXGate`) you can specify the class. If the class is specified than the ``name`` argument must be specified. When a class is used the gate is treated as global and not having any properties set. properties (dict): A dictionary of qarg entries to an :class:`~qiskit.transpiler.InstructionProperties` object for that instruction implementation on the backend. Properties are optional for any instruction implementation, if there are no :class:`~qiskit.transpiler.InstructionProperties` available for the backend the value can be None. If there are no constraints on the instruction (as in a noiseless/ideal simulation) this can be set to ``{None, None}`` which will indicate it runs on all qubits (or all available permutations of qubits for multi-qubit gates). The first ``None`` indicates it applies to all qubits and the second ``None`` indicates there are no :class:`~qiskit.transpiler.InstructionProperties` for the instruction. By default, if properties is not set it is equivalent to passing ``{None: None}``. name (str): An optional name to use for identifying the instruction. If not specified the :attr:`~qiskit.circuit.Instruction.name` attribute of ``gate`` will be used. All gates in the ``Target`` need unique names. Backends can differentiate between different parameterization of a single gate by providing a unique name for each (e.g. `"rx30"`, `"rx60", ``"rx90"`` similar to the example in the documentation for the :class:`~qiskit.transpiler.Target` class). Raises: AttributeError: If gate is already in map TranspilerError: If an operation class is passed in for ``instruction`` and no name is specified or ``properties`` is set. zLA name must be specified when defining a supported global operation by classNzAAn instruction added globally by class can't have properties set.z Instruction z is already in the target) inspectisclassnamerrmAttributeErrorr&add_instructionrnrorp)r; instruction propertiesris_classinstruction_namer-s r.rzTarget.add_instructionhsF?;// $#7{'7   %b%%W $    J t~ - - ![0@![![![\\ \  -=zJJJ+5'(#&*#)-&&&r/ct|||||j||<d|_d|_dS)aUpdate the property object for an instruction qarg pair already in the Target Args: instruction (str): The instruction name to update qargs (tuple): The qargs to update the properties of properties (InstructionProperties): The properties to set for this instruction Raises: KeyError: If ``instruction`` or ``qarg`` are not in the target N)r&update_instruction_propertiesrmrorp)r;rqargsrr-s r.rz$Target.update_instruction_propertiessH --k5*MMM-7{#E*&*#)-&&&r/cPt|d}t}||||jD]g}i}||D]} t |}n#t $r|f}YnwxYw |j||} n#tt f$rd} YnwxYw|||} | j ret| dd| krP|j 5 | j |j z} n#t$rd} YnwxYwd} t| | } n|  |||| _n#tt f$rYnwxYw| ||<|s!||jvr||vr\||} i} |D]#\}}t#|| jkr|| |<$|| | |t)}t)}||D]}t+|t,r|f}|t#|t|t |d}|t |jt#|dkst#|dkrt7d|d|d |d t9|t;t=|t?tAtBt;t=| } || ||&|D],\}}||j|vr|"|||-idS) anUpdate the target from an instruction schedule map. If the input instruction schedule map contains new instructions not in the target they will be added. However, if it contains additional qargs for an existing instruction in the target it will error. Args: inst_map (InstructionScheduleMap): The instruction inst_name_map (dict): An optional dictionary that maps any instruction name in ``inst_map`` to an instruction object. If not provided, instruction is pulled from the standard Qiskit gates, and finally custom gate instance is created with schedule name. error_dict (dict): A dictionary of errors of the form:: {gate_name: {qarg: error}} for example:: {'rx': {(0, ): 1.4e-4, (1, ): 1.2e-4}} For each entry in the ``inst_map`` if ``error_dict`` is defined a when updating the ``Target`` the error value will be pulled from this dictionary. If one is not found in ``error_dict`` then ``None`` will be used. _get_calibration_entryNr#)r)r0rr[zSchedules for z6 are defined non-uniformly for multiple qubit lengths z, or different parameter names zo. Provide these schedules with inst_name_map or define them with different names for different gate parameters.)rrsparams)#getattrr update instructionsqubits_with_instructionrU TypeErrorrmKeyErrorrMrurKr)rr"r*itemslenrsrsetrNrtadd get_signature parameterskeysrr nextiterlistmapr r)r;inst_map inst_name_map error_dictget_calibrationqiskit_inst_name_map inst_name out_propsrpropsentryr)inst_objnormalized_propspropqlen param_namescals r.$update_from_instruction_schedule_mapz+Target.update_from_instruction_schedule_mapsv6"(,DEE >??  $ ' ' 6 6 6!.S OS OII!99)DD$ )$ )%!%LLEE %%%"HEEE%! N95eEKK ),D#( %   .. 4443I>H')$'0'8'877 tu::)<<<$26(//((3C)(TTTT55D"%%%K!)!A!A)!L!LVV%eS11-%*HEU,,,%ie &=~NN#c.?.?.A.A.L.Q.Q.S.S(T(TUUUU4yy1}}K(8(81(<(<)MYMM6:MM> D  D (D<<EEcbd|j|vrdS|j|S)zGet the qargs for a given operation name Args: operation (str): The operation name to get qargs for Returns: set: The set of qargs the gate instance applies to. Nrmr)r; operations r.qargs_for_operation_namezTarget.qargs_for_operation_nameIs4 4>), , ,4~i(--///r/c@|j|jSg}|jD]S\}}|D]9\}}|2|j+||t ||jdf:Tt ||j|_|jS)zGet an InstructionDurations object from the target Returns: InstructionDurations: The instruction duration represented in the target Ns)ru)rormrr)appendrrru)r; out_durationsr props_mapqargrs r. durationszTarget.durationsUs  & 2. . &*n&:&:&<&< ^ ^ "K$-OO$5$5 ^ ^ j)j.A.M!((+tDzz:CVX[)\]]] ^';=TW&U&U&U#**r/cNt|j|j|j|jS)zGet an :class:`~qiskit.transpiler.TimingConstraints` object from the target Returns: TimingConstraints: The timing constraints represented in the ``Target`` )rrvrwrxryr?s r.timing_constraintszTarget.timing_constraintsfs* !  dot/CTE[   r/c*|S)a,Return an :class:`~qiskit.pulse.InstructionScheduleMap` for the instructions in the target with a pulse schedule defined. Returns: InstructionScheduleMap: The instruction schedule map for the instructions in this target with a pulse schedule defined. )_get_instruction_schedule_mapr?s r.instruction_schedule_mapzTarget.instruction_schedule_mapps11333r/c|j|jStj5tjdtt }dddn #1swxYwY|jD]I\}}|D]/\}}t|dd}|| |||0J||_|S)NrCrDr#) rprGrHrIrJrrmrr_add)r;out_inst_schedule_maprrrr cal_entrys r.rz$Target._get_instruction_schedule_map{s)  ) 51 1  $ & & = =  !:5A>RR %y%t6v666r/c4|jS)z&Get the operation names in the target.rr?s r.operation_nameszTarget.operation_namess~""$$$r/cNfdjDS)a"Get the list of tuples (:class:`~qiskit.circuit.Instruction`, (qargs)) for the target For globally defined variable width operations the tuple will be of the form ``(class, None)`` where class is the actual operation class that is globally defined. c>g|]\}}|D]}j||fSr2)r).0oprrr;s r. z'Target.instructions..sQ   E    $d +    r/rmrr?s`r.rzTarget.instructionss<    !^1133    r/cXd|jD}||S)aGet the instruction properties for a specific instruction tuple This method is to be used in conjunction with the :attr:`~qiskit.transpiler.Target.instructions` attribute of a :class:`~qiskit.transpiler.Target` object. You can use this method to quickly get the instruction properties for an element of :attr:`~qiskit.transpiler.Target.instructions` by using the index in that list. However, if you're not working with :attr:`~qiskit.transpiler.Target.instructions` directly it is likely more efficient to access the target directly via the name and qubits to get the instruction properties. For example, if :attr:`~qiskit.transpiler.Target.instructions` returned:: [(XGate(), (0,)), (XGate(), (1,))] you could get the properties of the ``XGate`` on qubit 1 with:: props = target.instruction_properties(1) but just accessing it directly via the name would be more efficient:: props = target['x'][(1,)] (assuming the ``XGate``'s canonical name in the target is ``'x'``) This is especially true for larger targets as this will scale worse with the number of instruction tuples in a target. Args: index (int): The index of the instruction tuple from the :attr:`~qiskit.transpiler.Target.instructions` attribute. For, example if you want the properties from the third element in :attr:`~qiskit.transpiler.Target.instructions` you would set this to be ``2``. Returns: InstructionProperties: The instruction properties for the specified instruction tuple c@g|]}|D]}|Sr2)values)rr inst_propss r.rz1Target.instruction_properties.. sA" " "  ellnn" " @JJ" " " " r/rmr)r;indexinstruction_propertiess r.rzTarget.instruction_propertiess=F" " $(N$9$9$;$;" " " &e,,r/cHtjd|_|j6|jdt |jD|jD]\}}|!|j|jdkr d|_dS(|D]\}}|*| |jdkr d|_dS1t|dkr||j|d<Ut|dkrA |jj |}|||<~#tj $r|jj g|||iRYwxYw|j}|jdkr$|t!d|Dr d|_dSdSdS)NF multigraphcg|]}iSr2r2)r_s r.rz0Target._build_coupling_graph..(s0T0T0T0T0T0Tr/r\r[rc3K|]}|duV dSr%r2rxs r. z/Target._build_coupling_graph..As& : :qd : : : : : :r/)rx PyDiGraphrnrsadd_nodes_fromrangermrroperation_from_namer get_edge_dataNoEdgeBetweenNodesadd_edger num_edgesany)r;gateqarg_maprr edge_datars r._build_coupling_graphzTarget._build_coupling_graph%s!|u=== ? &  / /0T0TU4?=S=S0T0T0T U U U"n2244 Q QND(&t,71<<+/D(FF$,NN$4$4 Q Q j<//55@AEE/3,t99>>"(a11YY!^^Q$FD$8$F$M *4 $0QQQ5,5PtPdJ=OPPPPPPQ $ Q     ) ) + +q 0 0 MS : :E : : :::M#'D  1 0 MsD++%EEFc|jdSd|jvr8td|jDrtd|t jd}|dg|jz||D]<\}}t|dkrtd|d|j g|||iR=t}||_ |S|j||jJt}|r||_ n|j|_ |SdS) a7Get a :class:`~qiskit.transpiler.CouplingMap` from this target. If there is a mix of two qubit operations that have a connectivity constraint and those that are globally defined this will also return ``None`` because the globally connectivity means there is no constraint on the target. If you wish to see the constraints of the two qubit operations that have constraints you should use the ``two_q_gate`` argument to limit the output to the gates which have a constraint. Args: two_q_gate (str): An optional gate name for a two qubit gate in the ``Target`` to generate the coupling map for. If specified the output coupling map will only have edges between qubits where this gate is present. filter_idle_qubits (bool): If set to ``True`` the output :class:`~.CouplingMap` will remove any qubits that don't have any operations defined in the target. Note that using this argument will result in an output :class:`~.CouplingMap` object which has holes in its indices which might differ from the assumptions of the class. The typical use case of this argument is to be paired with :meth:`.CouplingMap.connected_components` which will handle the holes as expected. Returns: CouplingMap: The :class:`~qiskit.transpiler.CouplingMap` object for this target. If there are no connectivity constraints in the target this will return ``None``. Raises: ValueError: If a non-two qubit gate is passed in for ``two_q_gate``. IndexError: If an Instruction not in the ``Target`` is passed in for ``two_q_gate``. Nc3<K|]}t|dkVdS)r\N)rrs r.rz,Target.build_coupling_map..hs,)I)I#a&&1*)I)I)I)I)I)Ir/zThis Target object contains multiqubit gates that operate on > 2 qubits. This will not be reflected in the output coupling map.Frr\zSpecified two_q_gate: z is not a 2 qubit instruction)rrloggerwarningrrrrsrr ValueErrorrrgraphrnr_filter_coupling_graphcopy)r; two_q_gatefilter_idle_qubitscoupling_graphrrcmaps r.build_coupling_mapzTarget.build_coupling_mapEsB : 4 tz ! !c)I)Idj)I)I)I&I&I ! NN+     !\U;;;N  ) )4&4?*B C C C%)*%5%;%;%=%= J J!zu::??$ZZZZ('IIZ0HIIIII==D'DJK   '  & & ( ( (   +==D! 9!88:: !16688 K4r/c^ttjd|jD}|j}t||}|r"| t||S)Nc3K|]}||V dSr%r2rs r.rz0Target._filter_coupling_graph..s(:b:bTUTa1TaTaTaTa:b:br/) r itertoolschain from_iterablerrnr node_indices differenceremove_nodes_fromr)r;has_operationsr to_removes r.rzTarget._filter_coupling_graphsY_:::b:bdj:b:b:bbbcc$))++**,,--88HH  5  # #DOO 4 4 4 r/c*t|jSr%)rrmr?s r.__iter__zTarget.__iter__sDN###r/c|j|Sr%rm)r;keys r. __getitem__zTarget.__getitem__s~c""r/c8 ||S#t$r|cYSwxYw)zOGets an item from the Target. If not found return a provided default or `None`.)r)r;rdefaults r.getz Target.gets5 9    NNN s  c*t|jSr%)rrmr?s r.__len__zTarget.__len__s4>"""r/c||jvSr%r)r;items r. __contains__zTarget.__contains__st~%%r/c4|jS)z/Return the keys (operation_names) of the Targetrr?s r.rz Target.keyss~""$$$r/c4|jS)z[Return the Property Map (qargs -> InstructionProperties) of every instruction in the Targetrr?s r.rz Target.valuess~$$&&&r/c4|jS)zZReturns pairs of Gate names and its property map (str, dict[tuple, InstructionProperties])rr?s r.rz Target.itemss~##%%%r/c6tj}|j|d|jdn|d|d|jd|d|jD]j\}}|d|d|D]5\}}| ||d|d%d|dg}t|d d}||d |d d t|d d}||d|d dt|dd} | |dt|dd} | Ld| D} d | } |d| d|d |7l| S)NzTarget:  zTarget zNumber of qubits: zInstructions:  z z: r)z Duration: gz sec. r*z Error Rate: r#z# With pulse schedule calibration rc&g|]\}}d|d|dS)z z: r$r2)rrvalues r.rz"Target.__str__..s=***8BU3333%333***r/z Extra properties: ) ioStringIOrqwritersrmrrrjoingetvalue) r;outputinst qarg_propsrrprop_str_piecesr)r*schedule extra_propsextra_props_piecesextra_props_strs r.__str__zTarget.__str__se   ' LL8D$4888 9 9 9 9 LL $ $ $ =$/===>>> &''' $ 4 4 6 6 7 7 D* LLd ' ' ')//11 7 7 e<=LL111#3$#3#3#3"4"5*d;;'#**+Qh+Q+Q+Q+QRRRw55$#**+K+K+K+K+KLLL"5.$??'#**+TUUU%e\4@@ ***FQFWFWFYFY***&')gg.@&A&AO#**+Z+Z+Z+Z[[[ RWW_556666/ 70   r/dictcx|j|j|j|jt dS)N)rmrinstruction_durationsrbase)rmrnrorpr&rWrXs r.rWzTarget.__getstate__s<"2%)%@(,(FGG((**    r/rYrUc|d|_|d|_|d|_|d|_t |ddS)Nrmrr:rr;)rmrnrorpr&r]r^s r.r]zTarget.__setstate__s[{+$%56&+,C&D#)./I)J& U6]+++++r/rbackend_propertiesz1.4Qiskitz in Qiskit 2.0zgTo add instructions with specific properties use Target.add_instruction(instruction, properties, name).)rsince package_nameremoval_timelineadditional_msg basis_gates list[str] int | None coupling_mapCouplingMap | NoneInstructionScheduleMap | NoneBackendProperties | Noner:InstructionDurations | NoneOptional[List[List[int]]]rTimingConstraints | Nonecustom_name_mappingdict[str, Any] | Nonec h d} d} d} d}| | j} | j} | j} | j}d}|ddlm}||}|||| | | |||}t }| || |;|D]6}||vrtd|d| ||| 7ng}g}g}|t|j }|D]}||vrtd|d||}|j dkr| |B|j d kr| |ctj|r| |t!d|d |j d |D]}i}t#|D]K}d}d}d}|V|* |||}n#t&$rd}YnwxYw |||}n#t&$rd}YnwxYw|O |||}|r#|jr|j|z}n#t2$rd}YnwxYw|, |||d }n#t $rd}YnwxYw| | |d||f<t7j5t7jdt<ddt?|||||f<dddn #1swxYwYM| ||||tA|!}|D]p}i}|D]I}d}d}d}|V|* |||}n#t&$rd}YnwxYw |||}n#t&$rd}YnwxYw|O |||}|r#|jr|j|z}n#t2$rd}YnwxYw|, |||d }n#t $rd}YnwxYw| ||d||<t7j5t7jdt<ddt?|||||<dddn #1swxYwYK| ||||r|D]}| |||  |S)aCreate a target object from the individual global configuration Prior to the creation of the :class:`~.Target` class, the constraints of a backend were represented by a collection of different objects which combined represent a subset of the information contained in the :class:`~.Target`. This function provides a simple interface to convert those separate objects to a :class:`~.Target`. This constructor will use the input from ``basis_gates``, ``num_qubits``, and ``coupling_map`` to build a base model of the backend and the ``instruction_durations``, ``backend_properties``, and ``inst_map`` inputs are then queried (in that order) based on that model to look up the properties of each instruction and qubit. If there is an inconsistency between the inputs any extra or conflicting information present in ``instruction_durations``, ``backend_properties``, or ``inst_map`` will be ignored. Args: basis_gates: The list of basis gate names for the backend. For the target to be created these names must either be in the output from :func:`~.get_standard_gate_name_mapping` or present in the specified ``custom_name_mapping`` argument. num_qubits: The number of qubits supported on the backend. coupling_map: The coupling map representing connectivity constraints on the backend. If specified all gates from ``basis_gates`` will be supported on all qubits (or pairs of qubits). inst_map: DEPRECATED. The instruction schedule map representing the pulse :class:`~.Schedule` definitions for each instruction. If this is specified ``coupling_map`` must be specified. The ``coupling_map`` is used as the source of truth for connectivity and if ``inst_map`` is used the schedule is looked up based on the instructions from the pair of ``basis_gates`` and ``coupling_map``. If you want to define a custom gate for a particular qubit or qubit pair, you can manually build :class:`.Target`. backend_properties: The :class:`~.BackendProperties` object which is used for instruction properties and qubit properties. If specified and instruction properties are intended to be used then the ``coupling_map`` argument must be specified. This is only used to lookup error rates and durations (unless ``instruction_durations`` is specified which would take precedence) for instructions specified via ``coupling_map`` and ``basis_gates``. instruction_durations: Optional instruction durations for instructions. If specified it will take priority for setting the ``duration`` field in the :class:`~InstructionProperties` objects for the instructions in the target. concurrent_measurements(list): A list of sets of qubits that must be measured together. This must be provided as a nested list like ``[[0, 1], [2, 3, 4]]``. dt: The system time resolution of input signals in seconds timing_constraints: Optional timing constraints to include in the :class:`~.Target` custom_name_mapping: An optional dictionary that maps custom gate/operation names in ``basis_gates`` to an :class:`~.Operation` object representing that gate/operation. By default, most standard gates names are mapped to the standard gate object from :mod:`qiskit.circuit.library` this only needs to be specified if the input ``basis_gates`` defines gates in names outside that set. Returns: Target: the target built from the input configuration Raises: TranspilerError: If the input basis gates contain > 2 qubits and ``coupling_map`` is specified. KeyError: If no mapping is available for a specified ``basis_gate``. r[Nr)qubit_props_list_from_props)r)rsrurvrwrxryrzr|zThe specified basis gate: zL is not present in the standard gate names or a provided custom_name_mappingrr\z has z qubits. This constructor method only supports fixed width operations with <= 2 qubits (because connectivity is defined on a CouplingMap).r)unitrCz2.*``calibration`` is deprecated as of Qiskit 1.3.*qiskit)rFmessagemodule)r)r*r0)rr)"rvrwrxryqiskit.providers.backend_compatrPr rrrrrrsrrrrr gate_lengthr gate_errorrrMrKr)rrrGrHfilterwarningsrJr"r get_edges)r(rCrsrFrr=r:r|rurrMrvrwrxryrzrPtarget name_mappingrone_qubit_gatestwo_qubit_gates!global_ideal_variable_width_gatesgate_objgate_propertiesqubitr*r)r0edgesedges r.from_configurationzTarget.from_configurationsp    ),8K+6J0@O 2 D   ) S S S S S S::FXYYY !#!+/-$;    677  *    3 4 4 4  # F F|++"BTBBB&&|D'9&EEEE  F!O O02 -! !344 #  |++"BTBBB(-&!++#**40000(A--#**40000_X..5<Q4811%466  $3 ();(\'/  9N)1K999OUH5               &&|D'9o\`&aaaa//1122E'/ b/ b"$!,,D E#H"&K)5#+0+=+I+I$PT+U+U#7000+/0)$6$A$A$$M$MEE3)))$(EEE)+ /*2*I*I$PT*U*UK "Tk&?T+6+C+C+E+E+NQS+S)///*.KKK/-8,'<'@'@tRU'@'V'VHH.,,,'+HHH,})9k>Q04--%466  $3 ();(\'/  5J)1K555OD1               &&|D'9o\`&aaaa9 F F&&|D'9&EEEE sF33 GGG G,+G,2;H.. H=<H=I I+*I+4KK K 3M  MMM44 NN ;O OOO33 PP$3Q##Q' *Q' ) NrNr[r[r[r[NN)rqrrrsrtrur6rvrtrwrtrxrtryrtrzr{r|r{r_r%)rr~rrrrrTr) rr~rrr+r rrr,r rTr)NF)rTr8r`) NNNNNNNNN)rCrDrsrErFrGrrHr=rIr:rJr|rKrur6rrLrMrNrTrk)+rarbrcrdrer'r9rrrrrrrrrrrrrrfrrrrrrrrrrrrrrr7rWr] classmethodr rrdrhris@r.rkrksQQfI#' !"(,/3E E E E E E E R  $....$Y.Y.Y.Y.Y.Y.v . . . . . tOtOtO tOl 0 0 0+++"    44 4%%%( 8< NNNN N28< `````, 8<        D8< 777777 %%X%   X  &-&-&-P(((@BBBBH$$$######&&&%%%'''&&&"!"!"!H      ,,,,,,$$] !(E "&+/267;=A=A7;59wwww%$[wwwwwr/rkz1.2zin the 2.0 releaseaNThis method is used to build an element from the deprecated ``qiskit.providers.models`` module. These models are part of the deprecated `BackendV1` workflow and no longer necessary for `BackendV2`. If a user workflow requires these representations it likely relies on deprecated functionality and should be updated to use `BackendV2`.)r?rArBrZc 6 dddgd}g}g}|D]\}}|dkr!|D] \}}g}t|ddK|tjtjjdd|jdt|d dK|tjtjjd d|jd|rG||t|||d d |Dzd  .i |j dt|j D |D]\}}||d} g} t|d dK| tjtjjdd|jdt|ddK| tjtjjdd|jd| si n| | <։ rKtd Dr fdt|j D}|s|rf||d<||d<tj5tjdt$t'j|cdddS#1swxYwYdSdS)zMConvert a :class:`~.Target` object into a legacy :class:`~.BackendProperties`r)N) backend_namebackend_versionlast_update_dategeneralmeasurer)rVr)daterrQr(r*rWrc,g|]}t|Sr2)r~rs r.rz0target_to_backend_properties..s4K4K4KSVV4K4K4Kr/)rqubitsrrci|]}|dSr%r2rs r. z0target_to_backend_properties..!sIII1q$IIIr/r readout_errorreadout_lengthc3K|]}|duV dSr%r2rs r.rz/target_to_backend_properties..=s&"O"OQ1D="O"O"O"O"O"Or/c g|] }| Sr2r2)ri qubit_propss r.rz0target_to_backend_properties..>sKKKQ+a.KKKr/gatesrnrC)rF)rrrdatetimenowtimezoneutcr)r*rr-rsrallrrGrHrXrJr from_dict) rZproperties_dictrwrnr qargs_listrr property_listra props_listrvs @r.target_to_backend_propertiesrs  ''O E F"LLNN?L?Lj 9   * 0 0 2 2   u " 5*d33?!(($,$5$9$9(:K:O$P$P$1$'%*^ 5'400<!(($,$5$9$9(:K:O$P$P$0$&%*[ !LL$(&*5kk*7$(3884K4KU4K4K4K+L+L$L + <+-K ,IIf6G0H0HIII * 0 0 2 2 0 0 u=a 5'400<%%$,$5$9$9(:K:O$P$P$3$&%*[ 5*d33?%%$,$5$9$9(:K:O$P$P$4$'%*^ ""$KE%/ E"" Ls"O"O+:L:L:N:N"O"O"OOO LKKKK%8I2J2JKKK #( $*!  $ & & @ @  #H7I J J J J$.?? @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ ts/L  LL)rZrk)Drd __future__rr rGtypingrrrcollections.abcrrxr*loggingr rustworkxrqiskit._accelerate.targetrr qiskit.circuit.parameterr "qiskit.circuit.parameterexpressionr qiskit.circuit.gater %qiskit.circuit.library.standard_gatesr %qiskit.pulse.instruction_schedule_mapr qiskit.pulse.calibration_entriesrrqiskit.pulse.schedulerrqiskit.transpiler.couplingrqiskit.transpiler.exceptionsr'qiskit.transpiler.instruction_durationsr$qiskit.transpiler.timing_constraintsrqiskit.providers.exceptionsrqiskit.pulse.exceptionsrrqiskit.exceptionsrqiskit.providers.backendr)qiskit.providers.models.backendpropertiesr qiskit.utilsrrqiskit.utils.deprecate_pulserr getLoggerrarr"rkregisterrr2r/r.rs #"""""&&&&&&&&&&######  /.....AAAAAA$$$$$$PPPPPPHHHHHHJJJJJJJJ99999999222222888888HHHHHHBBBBBB<<<<<<GGGGGGGG))))))544444GGGGGG66666666XXXXXXXX  8 $ $o%o%o%o%o%5o%o%o%dqqqqqZqqqh! ),SSSSSSr/