gidZddlmZddlZddlZddlmZddlZddlm Z m Z ddl Z ddl m Z ddlmZmZddlmZdd lmZdd lmZdd lmZmZdd lmZd ZGddeZdS)a A generic quantum instruction. Instructions can be implementable on hardware (u, cx, etc.) or in simulation (snapshot, noise, etc.). Instructions can be unitary (a.k.a Gate) or non-unitary. Instructions are identified by the following: name: A string to identify the type of instruction. Used to request a specific instruction on the backend, or in visualizing circuits. num_qubits, num_clbits: dimensions of the instruction. params: List of parameters to specialize a specific instruction instance. Instructions do not have any context about where they are in a circuit (which qubits/clbits). The circuit itself keeps this context. ) annotationsN) zip_longest)ListType) CircuitError)ClassicalRegisterClbit)QasmQobjInstruction)ParameterExpression) Operation)AnnotatedOperationInverseModifier)deprecate_func绽|=ceZdZdZdZdZdCdZedDdZedEd Z d Z ee d d ddZ e j dZ dZdFdZdGdZdZedZej dZdZdZedZej dZedZej d Zd!Zee d d"dd#Zej d$Zee d d"dd%Zej d&Ze d'd(d)*d+Zd,ZedFd-Zej dHd/Zd0ZdIdJd2Ze d d 3d4ZdKd5Z dKd6Z!d7Z"d8Z#d9Z$ee d d ddLd;Z%ed<Z&e&j d=Z&ed>Z'e'j d?Z'ed@Z(e(j dAZ(dBZ)dS)M InstructionzGeneric quantum instruction.FNdtc8t|trt|tstd|dks|dkrtd|d|d||_||_||_g|_t|ds-|$t|tstd||_ d|_ d|_ |tjd td ||_|"|d krtjd td ||_||_dS)aCreate a new instruction. .. deprecated:: 1.3 The parameters ``duration`` and ``unit`` are deprecated since Qiskit 1.3, and they will be removed in 2.0 or later. An instruction's duration is defined in a backend's Target object. Args: name (str): instruction name num_qubits (int): instruction's qubit width num_clbits (int): instruction's clbit width params (list[int|float|complex|str|ndarray|list|ParameterExpression]): list of parameters duration (int|float): (DEPRECATED) instruction's duration. it must be an integer if ``unit`` is ``'dt'`` unit (str): (DEPRECATED) time unit of duration label (str or None): An optional label for identifying the instruction. Raises: CircuitError: when the register is not in the correct format. TypeError: when the optional label is provided, but it is not a string. z*num_qubits and num_clbits must be integer.rzbad instruction dimensions: z qubits, z clbits._labelNlabel expects a string or NonezSetting a custom duration per instruction is deprecated as of Qiskit 1.3.0. It will be removed in Qiskit 2.0.0. An instruction's duration is defined in a backend's Target object.) stacklevelrzSetting a custom unit for duration per instruction is deprecated as of Qiskit 1.3.0. It will be removed in Qiskit 2.0.0. An instruction's duration is defined in a backend's Target object which has a fixed unit in seconds.) isinstanceintr_name _num_qubits _num_clbits_paramshasattrstr TypeErrorr _condition _definitionwarningswarnDeprecationWarning _duration_unitparams)selfname num_qubits num_clbitsr)durationunitlabels P/granary/edev/quantum/lib/python3.11/site-packages/qiskit/circuit/instruction.py__init__zInstruction.__init__@sa.*c** M*Z2M2M MKLL L >>Z!^^XzXXJXXX  %% tX&&  E3)?)?  @AAADK    M;#     "   M]#       returnType[Instruction]c t|S)aRGet the base class of this instruction. This is guaranteed to be in the inheritance tree of ``self``. The "base class" of an instruction is the lowest class in its inheritance tree that the object should be considered entirely compatible with for _all_ circuit applications. This typically means that the subclass is defined purely to offer some sort of programmer convenience over the base class, and the base class is the "true" class for a behavioral perspective. In particular, you should *not* override :attr:`base_class` if you are defining a custom version of an instruction that will be implemented differently by hardware, such as an alternative measurement strategy, or a version of a parametrized gate with a particular set of parameters for the purposes of distinguishing it in a :class:`.Target` from the full parametrized gate. This is often exactly equivalent to ``type(obj)``, except in the case of singleton instances of standard-library instructions. These singleton instances are special subclasses of their base class, and this property will return that base. For example:: >>> isinstance(XGate(), XGate) True >>> type(XGate()) is XGate False >>> XGate().base_class is XGate True In general, you should not rely on the precise class of an instruction; within a given circuit, it is expected that :attr:`Instruction.name` should be a more suitable discriminator in most situations. )typer*s r1 base_classzInstruction.base_classs<Dzzr3boolcdS)zIs this instance is a mutable unique instance or not. If this attribute is ``False`` the gate instance is a shared singleton and is not mutable. Tr8s r1mutablezInstruction.mutables tr3c*|S)a8Return a mutable copy of this gate. This method will return a new mutable copy of this gate instance. If a singleton instance is being used this will be a new unique instance that can be mutated. If the instance is already mutable it will be a deepcopy of that instance. )copyr8s r1 to_mutablezInstruction.to_mutablesyy{{r3z1.3.0zin 2.0.0T)sinceremoval_timeline is_propertyc|jS)z+The classical condition on the instruction.r"r8s r1 conditionzInstruction.conditions r3c||_dSNrE)r*rFs r1rFzInstruction.conditions #r3c.t|trN|j|jus@|j|jks0|j|jks |j|jks|j|jkrdSt|j|jD]\}}t|tj rtj ||r6n||kr> tj |}tj |}tj |tj |krtj||tdrn#t t"f$rYnwxYw tjt'|t'|tdrn#t"$rYnwxYwdSdS)zTwo instructions are the same if they have the same name, same dimensions, and same params. Args: other (instruction): other instruction Returns: bool: are self and other equal. Fr)atolrtolT)rrr9r+r,r- definitionrr)numpyndarray array_equalasarrayshapeallclose_CUTOFF_PRECISION ValueErrorr!isclosefloat)r*other self_param other_param self_asarray other_asarrays r1__eq__zInstruction.__eq__s5+.. e&666yEJ&&%"222%"222%"2225'24; 'M'M   #J *em44 $Z==,, $}Z88 % k : : ;|,, M0J0JJJu~ 2C!PPPJ *     =*%%u['9'9@QXY    55ts%?A/D00EE7F FFr c Hd|jd|jd|jd|jd S)zGenerates a representation of the Instruction object instance Returns: str: A representation of the Instruction instance with the name, number of qubits, classical bits and params( if any ) zInstruction(name='z', num_qubits=z , num_clbits=z , params=)r+r,r-r)r8s r1__repr__zInstruction.__repr__sU C C C$/ C C/ C C48K C C C r3rW 'Instruction'c|j|jksJ|j|jks:|j|jks*t|jt|jkrdSt |j|jD]\}}t |tst |tr0t |tj rbt |tj rHtj |tj |krtj ||trn/ tj ||trn#t$rYnwxYwdSdS)a Soft comparison between gates. Their names, number of qubits, and classical bit numbers must match. The number of parameters must match. Each parameter is compared. If one is a ParameterExpression then it is not taken into account. Args: other (instruction): other instruction. Returns: bool: are self and other equal up to parameter expressions. F)rJT)r+r,r-lenr)rrr rMrNrQrRrSrUr!)r*rWrXrYs r1 soft_comparezInstruction.soft_comparesl I # #%"222%"2224;3u|#4#4445'24; 'M'M   #J *&9:: j0?? *em44 KQVQ^9_9_ ;z**ek+.F.FFF5> 2CLLLF}ZCTUUU! ! D55ts$E EEcdS)aPopulate the cached :attr:`_definition` field of this :class:`Instruction`. Subclasses should implement this method to provide lazy construction of their public :attr:`definition` attribute. A subclass can use its :attr:`params` at the time of the call. The method should populate :attr:`_definition` with a :class:`.QuantumCircuit` and not return a value.Nr<r8s r1_definezInstruction._define)s  r3c|jS)zPThe parameters of this :class:`Instruction`. Ideally these will be gate angles.)rr8s r1r)zInstruction.params2s |r3cg|_|D]_}t|tr|j|2|j||`dSrH)rrr appendvalidate_parameter)r* parameters single_params r1r)zInstruction.params7sz & K KL,(;<< K ##L1111 ##D$;$;L$I$IJJJJ  K Kr3c|S)z:Instruction parameters has no validation or normalization.r<)r* parameters r1rjzInstruction.validate_parameter@sr3c>td|jDS)zzReturn whether the :class:`Instruction` contains :ref:`compile-time parameters `.c3NK|] }t|to|jV!dSrH)rr rk).0params r1 z/Instruction.is_parameterized..GsF  LQJu1 2 2 Gu7G      r3)anyrr8s r1is_parameterizedzInstruction.is_parameterizedDs5  UYUa      r3cF|j||jS)z0Return definition in terms of other basic gates.)r#rfr8s r1rLzInstruction.definitionKs#   # LLNNNr3c||_dS)zSet gate representationN)r#)r*arrays r1rLzInstruction.definitionRs!r3c8ddlm}||S)zMGet the decompositions of the instruction from the SessionEquivalenceLibrary.rSessionEquivalenceLibrary)"qiskit.circuit.equivalence_libraryr{ get_entry)r*sels r1decompositionszInstruction.decompositionsWs) XWWWWW}}T"""r3c>ddlm}|||dS)zMSet the decompositions of the instruction from the SessionEquivalenceLibrary.rrzN)r|r{ set_entry)r*rr~s r1rzInstruction.decompositions_s1 XWWWWW dN+++++r3c>ddlm}|||dS)zHAdd a decomposition of the instruction to the SessionEquivalenceLibrary.rrzN)r|r{add_equivalence)r* decompositionr~s r1add_decompositionzInstruction.add_decompositiongs3 XWWWWW D-00000r3zin Qiskit 2.0.0c|jS)zGet the duration.r'r8s r1r.zInstruction.durationns ~r3c||_dS)zSet the duration.Nrr*values r1r.zInstruction.durationtsr3c|jS)zGet the time unit of duration.r(r8s r1r/zInstruction.unitys zr3c||_dS)zSet the time unit of duration.Nrrs r1r/zInstruction.units r3z1.2zin the 2.0 releasezThe `Qobj` class and related functionality are part of the deprecated `BackendV1` workflow, and no longer necessary for `BackendV2`. If a user workflow requires `Qobj` it likely relies on deprecated functionality and should be updated to use `BackendV2`.)rArBadditional_msgc*|S)zAssemble a QasmQobjInstruction) _assembler8s r1assemblezInstruction.assembles~~r3ctj5tjdtdt |j}dddn #1swxYwY|jrd|jD}||_|jr&tt|j|_ |j r&tt|j |_ |j r |j |_ |jr |j|_|S)Nignoreqiskit)categorymoduler+c\g|])}t|dr||n|*S)evalf)rr)rqxs r1 z)Instruction._assemble..s5TTT1GAw$7$7>aggajjjQTTTr3)r$catch_warningsfilterwarningsr&r r+r)r,listrangequbitsr-memoryr0r")r* instructionr)s r1rzInstruction._assembles3  $ & & > >  #H7IRZ [ [ [ [-49===K > > > > > > > > > > > > > > > ; (TT TTTF!'K  ? >!%eDO&<&!%eDO&<&DKKK<== =r3cd|jr|js|S||jdz}|j}t |jD]:}||j|j |j ;||_ |S)a2For a composite instruction, reverse the order of sub-instructions. This is done by recursively reversing all sub-instructions. It does not invert any gate. Returns: qiskit.circuit.Instruction: a new instruction with sub-instructions reversed. _reverser) r#r=r?r+copy_empty_likereversedri operation reverse_opsrclbitsrL)r* reverse_instreversed_definitioninsts r1rzInstruction.reverse_opss  t| 99;; yydi*&>@@T-.. _ _D  & &t~'A'A'C'CT[RVR] ^ ^ ^ ^"5 r3 annotatedc|rt|tS|jtd|jdddlm}|jdr|jdd}n |jdz}|jr5t||j |j|j }n*|||j |j }|j }|j |_t!|j D]:}||j|j|j;||_|S) a.Invert this instruction. If `annotated` is `False`, the inverse instruction is implemented as a fresh instruction with the recursively inverted definition. If `annotated` is `True`, the inverse instruction is implemented as :class:`.AnnotatedOperation`, and corresponds to the given instruction annotated with the "inverse modifier". Special instructions inheriting from Instruction can implement their own inverse (e.g. T and Tdg, Barrier, etc.) In particular, they can choose how to handle the argument ``annotated`` which may include ignoring it and always returning a concrete gate class if the inverse is defined as a standard gate. Args: annotated: if set to `True` the output inverse gate will be returned as :class:`.AnnotatedOperation`. Returns: The inverse operation. Raises: CircuitError: if the instruction is not composite and an inverse has not been implemented for it. Nzinverse() not implemented for .r)Gate_dgr_)r+r,r))r rrLrr+qiskit.circuitrendswithr-rr,r)r?r#r global_phaser_appendrinverserr)r*rrr+ inverse_gateinverse_definitionrs r1rzInstruction.inverseso6  ?%dO,=,=>> > ? "L LLLMM M'''''' 9  e $ $ %9SbS>DD9u$D ? b&??{'')) LL 4TdodkN^N^N`N`aaaL!-==??+=+J*J'T-.. [ [D  & &t~'='='?'?dk Z Z Z Z"4 r3)rArBct|ttfstd|dkrtdt|trt |}||f|_|S)aDSet a classical equality condition on this instruction between the register or cbit ``classical`` and value ``val``. .. note:: This is a setter method, not an additive one. Calling this multiple times will silently override any previously set condition; it does not stack. z.W%DDDwGDDDdDDDDr3cg|] }|D]}| Sr<r<)rqrcargs r1rz3Instruction.broadcast_arguments..Xrr3N)rcr,rr-)r*qargscargs flat_qargs flat_cargss r1broadcast_argumentszInstruction.broadcast_arguments<s u:: ( (EUEE15EEE  u:: ( (EUEE15EEE  ED%DDD DD%DDD *$$$$$$r3cZt|jd||j|j|jS)N*r_)rr+r,r-r))r*exponents r1_return_repeatzInstruction._return_repeat[s;I****;     r3c0t||ks|dkrtdt|}||}|jddlm}m}||j|j}t|j }t|j }| }|j r|}d|_dg|zD]"} |||||#||_|j r|j|j }|S)aCreates an instruction with ``self`` repeated :math`n` times. If this operation has a conditional, the output instruction will have the same conditional and the inner repeated operations will be unconditional; instructions within a compound definition cannot be conditioned on registers within Qiskit's data model. This means that it is not valid to apply a repeated instruction to a clbit that it both writes to and reads from in its condition. Args: n (int): Number of times to repeat the instruction Returns: qiskit.circuit.Instruction: Containing the definition. Raises: CircuitError: If n < 1. z9Repeat can only be called with strictly positive integer.Nr)QuantumCircuitCircuitInstruction)rrrrLrrrr,r-tuplerrr?r"r@rFrr) r*nrrrqcrrbase_s r1repeatzInstruction.repeatcs.$ q66Q;;!a%%Z[[ [ FF))!,,  ! ) I I I I I I I IAAB")$$E")$$E99;;D &((!%VaZ C C --dE5AABBBB%'K " ? =*+*DOX^'JDQQQRQX$$$000d     ((((T   X ]KK]K     X !!!##X#,,,111^'4ESWXXXYXX__^'4ESWXXXYXX [[^-0   0X \ > > >\ >477777r^'J???@?("%%%>   ***X^'JDQQQAAARQXAX [[  X &&&  X &&&r3r)r __future__rr?r$ itertoolsrrtypingrrrMqiskit.circuit.exceptionsr qiskit.circuit.classicalregisterrr qiskit.qobj.qasm_qobjr qiskit.circuit.parameterr qiskit.circuit.operationr "qiskit.circuit.annotated_operationr r qiskit.utilsrrSrr<r3r1r s?*#""""" !!!!!!  222222EEEEEEEE555555888888......RRRRRRRR''''''G G G G G )G G G G G r3