gK dZddlZddlZddlZddlmZmZddlZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZddlmZddlmZmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$ej%ej&ej'ej(d ej)ej*ej+ej,ej-ej.ej/ej0ej1ej2ej3ej4ej5ej6ej7ej8ej9ej:fZ;ej<d Gd d Z=de>fdZ?GddeZ@ge=dddej%e=dddej&e=dddej'e=dddej(e=dddejAe=ddde@d e=dddejBd e=dddejCd e=dddej)e=dddej*e=dddej+e=d ddej,e=d!ddej-e=d"ddej.e=d#ddej/e=d$ddej0e=d%ddej1e=d&ddej2e=d'ddej3e=d(ddejDd e=d)ddejEd e=d*ddej4e=d+ddej5e=d,ddejFd e=d-ddej6e=d.ddej7e=d/ddejGd e=d0ddejHd e=d1ddejId e=d2ddej8e=d3ddej9e=d4ddejJd e=d5ddej:e=d6ddejKd e=d7d8dejLd e=d9ddejMd e=d:ddejNd e=d;ddejOd e=ddd8ejRd e=d?dd@ejSd e=dAdde?RZTedBdejUedCdejVedDdejWfZXdEee=fdFZYGdGdHeZZdIZ[dJZ\dKZ]dS)LzOPython-space bytecode interpreter for the output of the main Rust parser logic.N)IterableCallable) BarrierCircuitInstructionClassicalRegisterDelayGate InstructionMeasureQuantumCircuitQuantumRegisterQubitResetlibrary)Operator) OpCode UnaryOpCode BinaryOpCodeCustomClassical ExprConstant ExprArgument ExprUnary ExprBinary ExprCustom)QASM2ParseErrorc.tjdddS)Nr)libUGateH/granary/edev/quantum/lib/python3.11/site-packages/qiskit/qasm2/parse.pyr#:sCIaA  r!T)frozencZeZdZUdZeed<eed<eed<edefed<dZ e ed<d S) CustomInstructionaInformation about a custom instruction that should be defined during the parse. The ``name``, ``num_params`` and ``num_qubits`` fields are self-explanatory. The ``constructor`` field should be a callable object with signature ``*args -> Instruction``, where each of the ``num_params`` ``args`` is a floating-point value. Most of the built-in Qiskit gate classes have this form. There is a final ``builtin`` field. This is optional, and if set true will cause the instruction to be defined and available within the parsing, even if there is no definition in any included OpenQASM 2 file. Examples: Instruct the importer to use Qiskit's :class:`.ECRGate` and :class:`.RZXGate` objects to interpret ``gate`` statements that are known to have been created from those same objects during OpenQASM 2 export:: from qiskit import qasm2 from qiskit.circuit import QuantumCircuit, library qc = QuantumCircuit(2) qc.ecr(0, 1) qc.rzx(0.3, 0, 1) qc.rzx(0.7, 1, 0) qc.rzx(1.5, 0, 1) qc.ecr(1, 0) # This output string includes `gate ecr q0, q1 { ... }` and `gate rzx(p) q0, q1 { ... }` # statements, since `ecr` and `rzx` are neither built-in gates nor in ``qelib1.inc``. dumped = qasm2.dumps(qc) # Tell the importer how to interpret the `gate` statements, which we know are safe # because we controlled the input OpenQASM 2 source. custom = [ qasm2.CustomInstruction("ecr", 0, 2, library.ECRGate), qasm2.CustomInstruction("rzx", 1, 2, library.RZXGate), ] loaded = qasm2.loads(dumped, custom_instructions=custom) name num_params num_qubits. constructorFbuiltinN) __name__ __module__ __qualname____doc__str__annotations__intrr r+boolr r!r"r&r&Psb''R IIIOOOOOO#{*++++GTr!r&timect||krtdtt|dS)NzCthe custom 'delay' instruction can only accept an integer parameterdt)unit)r2rr)r4s r"_generate_delayr8s= 4yyDcddd T & & &&r!c$eZdZfdZdZxZS)_U0Gatect||krtdtddt|gdS)Nz;the number of single-qubit delay lengths must be an integeru0r)r2rsuper__init__)selfcount __class__s r"r>z_U0Gate.__init__sM u::  !"_`` ` q3u::,/////r!ctd|_dg|jdzD]}|jddS)Nrr)r _definitionparamsid)r?_s r"_definez_U0Gate._definesR)!,,$+a.( # #A     " " " " # #r!)r,r-r.r>rG __classcell__rAs@r"r:r:sG00000 #######r!r:u3u2u1cxrEr<)r+upxyzhssdgttdgrxryrzsxsxdgczcyswapchccxcswapcrxcrycrzcu1cpcu3csxcurxxrzzrccxrc3xc3xc3sqrtxc4xdelayasinacosatancustom_instructionsc  t}gg}g}d\}}|D]7}||j|jdkrd}*|jdkrd}8|s|tj|s|tjt|}|D]} | j} | tj krD| j \} } } | t|| | fd| D^| tjkrtjdt"d| j \} } } }}|| | |j||}| t|fd | D| tjkrJ| j \}}| tt)|f||fK| tjkrtjd t"d| j \}}}}t)|j||}| t||f||f| tjkrC| tt-| j d f7| tjkrtjd t"d| j \}}}t-|j||}| t||f| tjkrX| j d } | tt1t3| fd | D/| tjkr>| j \}}t7||}|ddz ||}| tjkr>| j \}}t=||}||ddz }||| tjkr0| j \}|D]"}|t@|# | tj!krq| j \}}g}|D].}|jtj"krn||/|tG||tI||| tj%kr/| j \}}|tM||tOd| |S)aLoop through the Rust bytecode iterator `bytecode` producing a :class:`~qiskit.circuit.QuantumCircuit` instance from it. All the hard work is done in Rust space where operations are faster; here, we're just about looping through the instructions as fast as possible, doing as little calculation as we can in Python space. The Python-space components are the vast majority of the runtime. The "bytecode", and so also this Python function, is very tightly coupled to the output of the Rust parser. The bytecode itself is largely defined by Rust; from Python space, the iterator is over essentially a 2-tuple of `(opcode, operands)`. The `operands` are fixed by Rust, and assumed to be correct by this function. The Rust code is responsible for all validation. If this function causes any errors to be raised by Qiskit (except perhaps for some symbolic manipulations of `Parameter` objects), we should consider that a bug in the Rust code.)FFUTCXc g|] }| Sr r .0qqubitss r" z!from_bytecode..@^@^@^q@^@^@^r!zOConditioned gates in qasm2 will be loaded as an IfElseOp starting in Qiskit 2.0rK) stacklevelc g|] }| Sr r rs r"rz!from_bytecode.. s0N0N0Nq0N0N0Nr!zVConditioned measurements in qasm2 will be loaded as an IfElseOp starting in Qiskit 2.0rzPConditioned resets in qasm2 will be loaded as an IfElseOp starting in Qiskit 2.0c g|] }| Sr r rs r"rz!from_bytecode..#sCaCaCaRSF1ICaCaCar!Nzinvalid operation: )(r appendr*r'rrCXGateiteropcoderr operands_appendrConditionedGatewarningswarn FutureWarningc_ifcregsr ConditionedMeasurerConditionedResetrlen DeclareQregr add_register DeclareCregrSpecialIncludeQELIB1 DeclareGateEndDeclareGate _gate_buildertuple DeclareOpaque_opaque_builder ValueError)bytecoderzqcclbitsgateshas_uhas_cxcustombcoprgate_id parameters op_qubitscregvaluegatequbitclbitmeasureresetr'sizeregisterindicesindexr)inner_bcinner_oprs @r" from_bytecoders$   B F F E ME6% V'((( ;#  EE [D F   SY ! SZ    hBU9U9  V[ -/[ *GZ JJ">5>:#>@^@^@^@^T]@^@^@^__    v- - - Ma     ;=+ 7GZD%!5>:.33BHTNEJJD JJ)$0N0N0N0NI0N0N0NOO P P P P v~ % %;LE5 JJ)'))fUm5Eu GWXX Y Y Y Y v0 0 0 Mh     )+ %E5$iinnRXd^U;;G JJ)'F5M3CfUmEUVV W W W W v| # # JJ)%''F2;q>4J3LMM N N N N v. . . Mb     "$ E4GGLL$77E JJ)%&-1ABB C C C C v~ % % AI JJ)'#i..*A*ACaCaCaCaW`CaCaCabb c c c c v) ) )JD$&tT22H hqqqk !F OOH % % % % v) ) )JD$(t44H hqqqk !F OOH % % % % v, , ,JW  , , VE]++++ , v) ) )!{ D*H * *?f&;;;E)))) LLtZuxPP Q Q Q Q v+ + +!{ D* LLz:: ; ; ; ;727788 8 Ir!c@eZdZdZfdZdZddZdZfdZxZ S) _DefinedGatezA gate object defined by a `gate` statement in an OpenQASM 2 program. This object lazily binds its parameters to its definition, so it is only synthesized when required.c||_||_t||t |dSN)_gates _bytecoder=r>list)r?r'r)rDrrrAs r"r>z_DefinedGate.__init__Ps9 ! z4<<88888r!c BddgjzDt}jD]}|jtjkrU|j\}}}|tj |fd|Dfd|Dl|jtj krW|jd}|ttt|fd|Dtd||_ dS)Nc*g|]}tSr )r)rrFs r"rz(_DefinedGate._define..Ys<<z'_DefinedGate._define..`s1.`.`VW/A!T[/Q/Q.`.`.`.`.`.`r!c g|] }| Sr r rs r"rz(_DefinedGate._define..as666q666r!rc g|] }| Sr r rs r"rz(_DefinedGate._define..grr!z)received invalid bytecode to build gate: )r)r rrrr rrrrrrrrC)r?rrrargsrrs` @r"rGz_DefinedGate._defineUsT='>@^@^@^@^T]@^@^@^__!!QR!Q!QRRRr!Ncx|durtdtjt|j|S)NFz9unable to avoid copy while creating an array as requested)dtype)rnpasarrayr definition)r?rcopys r" __array__z_DefinedGate.__array__ms9 5==XYY Yz(4?335AAAAr!cB|j|j|j|j|jfSr)r'r)rDr _condition)r?s r" __getstate__z_DefinedGate.__getstate__us 4?DK$/ZZr!c|\}}}}}t|||d|_d|_||_||_dS)Nr )r=r>rrrCr)r?stater'r)rDr conditionrAs r" __setstate__z_DefinedGate.__setstate__xsP:?7j&*i z6222 %#r!)NN) r,r-r.r/r>rGrrrrHrIs@r"rrLsXX99999 0BBBB[[[$$$$$$$$$r!rcfd}|S)aqCreate a gate-builder function of the signature `*params -> Gate` for a gate with a given `name`. This produces a `_DefinedGate` class, whose `_define` method runs through the given `bytecode` using the current list of `known_gates` to interpret the gate indices. The indirection here is mostly needed to correctly close over `known_gates` and `bytecode`.c Dt|tSr)rr)rDr known_gatesr'r)s r"definerz_gate_builder..definersD*fk5??SSSr!r )r'r)rrrs```` r"rrs=TTTTTTTT Nr!cfd}|S)zCreate a gate-builder function of the signature `*params -> Gate` for an opaque gate with a given `name`, which takes the given numbers of qubits.c&t|Sr)r )rDr'r)s r"rz _opaque_builder..definersD*f---r!r )r'r)rs`` r"rrs)...... Nr!ct|tr|jSt|tr |jSt|t rt |j}|j}|tj kr| S|tj krtj |S|tjkrtj|S|tjkrtj|S|tjkrtj|S|tjkrtj|S|tjkrtj|St1d|t|t2rt |j}t |j}|j}|t8jkr||zS|t8jkr||z S|t8jkr||zS|t8j kr||z S|t8j!kr||zSt1d|t|tDr|j#fd|j$DSt1d|)zInner recursive function to calculate the value of a mathematical expression given the concrete values in the `parameters` field.zunhandled unary opcode: zunhandled binary opcode: c38K|]}t|VdSr)r)rrRrs r"rz%_evaluate_argument..s.YYQ1!Z@@YYYYYYr!zunhandled expression type: )% isinstancerrrrrrargumentrrNegateCosmathcosExpexpLnlogSinsinSqrtsqrtTantanrrleftrightrAddSubtractMultiplyDividePowerrcallable arguments)exprrinnerrrrs ` r"rrsS$ %%z$ %%&$*%%$ "">"4=*== [' ' '6M [_ $ $8E?? " [_ $ $8E?? " [^ # #8E?? " [_ $ $8E?? " [% % %9U## # [_ $ $8E?? ">>$ ##[t}YYYY$.YYYZZ 9499 : ::r!)^r/r dataclassesrtypingrrnumpyrqiskit.circuitrrrrr r r r r rrrrqiskit.quantum_inforqiskit._accelerate.qasm2rrrrrrrrr exceptionsrU3GateU2GateU1GaterXGateYGateZGateHGateSGateSdgGateTGateTdgGateRXGateRYGateRZGateCZGateCYGateCHGateCCXGateCRZGateCU1GateCU3Gater dataclassr&floatr8r:IGater PhaseGateSXGateSXdgGateSwapGate CSwapGateCRXGateCRYGate CPhaseGateCSXGateCUGateRXXGateRZZGateRCCXGateRC3XGateC3XGateC3SXGateC4XGateLEGACY_CUSTOM_INSTRUCTIONSrwrxryLEGACY_CUSTOM_CLASSICALrrrrrr r!r"r0sVU %%%%%%%%                            )(((((                      (''''' JJJJIIIIIKIKJJJJJJKKKK3 :d###0000000$#0f'%'''' # # # # #d # # #-dAq#*---dAq#*---dAq#*---dAq#*-- - dAq#),, -dAq'4888-c1aD999-c1a===-c1a++-c1a++-c1a++-c1a++-c1a++-eQ3;//- c1a++!-"eQ3;//#-$dAq#*--%-&dAq#*--'-(dAq#*--)-*dAq#*d;;;+-,faCL$???--.dAq#*--/-0dAq#*--1-2faCL$???3-4dAq#*--5-6eQ3;//7-8gq!S]DAAA9-:eQ3;===;-<eQ3;====->eQ3;//?-@eQ3;//A-BdAq#.$???C-DeQ3;//E-FeQ3;===G-HdAq#*d;;;I-JeQ3;===K-LeQ3;===M-NfaCL$???O-PfaCL$???Q-ReQ3;===S-TiAs|TBBBU-VeQ3;===W-Xgq!_55Y--`OFAty))OFAty))OFAty))z:K1Lzzzzz2$2$2$2$2$42$2$2$j   *;*;*;*;*;r!