gUdZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZddlmZddlmZmZmZmZmZmZddlZddlmZmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&dd l'm(Z(dd l)m*Z*m+Z+dd l,m-Z-ddl.m/Z/ej0dkrddlm1Z1nddl2m1Z1ej3dZ4de5d<edZ6eej7ej8fZ9ddZ:GddZ;e/ ddd#Zdd'Z?dd*Z@e/dd,ZAe/dd0ZBe/dd2ZCe/dd5ZDdd8ZEee/dd:ZFee/dd;ZGee/dd<ZHee/dd?ZIee/ddBZJeddEZKee/ddJZLee/dKdLddPZMe/ddRZNe/ddTZOe/ddVZPe/ddZZQe/ddd]ZRe/ddd`ZSGdadbedKcZTe/ddjZUe/dddkZVe/dddlZWe/dddmZXe/dddnZYe/dddsZZe/ dddzZ[e/dd|Z\e/dd}ddZ]ddZ^e/ dddZ_e/ddZ`e/ddZadS)a0 .. _pulse_builder: ============= Pulse Builder ============= .. We actually want people to think of these functions as being defined within the ``qiskit.pulse`` namespace, not the submodule ``qiskit.pulse.builder``. .. currentmodule: qiskit.pulse Use the pulse builder DSL to write pulse programs with an imperative syntax. .. warning:: The pulse builder interface is still in active development. It may have breaking API changes without deprecation warnings in future releases until otherwise indicated. The pulse builder provides an imperative API for writing pulse programs with less difficulty than the :class:`~qiskit.pulse.Schedule` API. It contextually constructs a pulse schedule and then emits the schedule for execution. For example, to play a series of pulses on channels is as simple as: .. plot:: :alt: Output from the previous code. :include-source: from qiskit import pulse dc = pulse.DriveChannel d0, d1, d2, d3, d4 = dc(0), dc(1), dc(2), dc(3), dc(4) with pulse.build(name='pulse_programming_in') as pulse_prog: pulse.play([1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1], d0) pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], d1) pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0], d2) pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], d3) pulse.play([1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0], d4) pulse_prog.draw() To begin pulse programming we must first initialize our program builder context with :func:`build`, after which we can begin adding program statements. For example, below we write a simple program that :func:`play`\s a pulse: .. plot:: :alt: Output from the previous code. :include-source: from qiskit import pulse d0 = pulse.DriveChannel(0) with pulse.build() as pulse_prog: pulse.play(pulse.Constant(100, 1.0), d0) pulse_prog.draw() The builder initializes a :class:`.pulse.Schedule`, ``pulse_prog`` and then begins to construct the program within the context. The output pulse schedule will survive after the context is exited and can be used like a normal Qiskit schedule. Pulse programming has a simple imperative style. This leaves the programmer to worry about the raw experimental physics of pulse programming and not constructing cumbersome data structures. We can optionally pass a :class:`~qiskit.providers.Backend` to :func:`build` to enable enhanced functionality. Below, we prepare a Bell state by automatically compiling the required pulses from their gate-level representations, while simultaneously applying a long decoupling pulse to a neighboring qubit. We terminate the experiment with a measurement to observe the state we prepared. This program which mixes circuits and pulses will be automatically lowered to be run as a pulse program: .. plot:: :alt: Output from the previous code. :include-source: from math import pi from qiskit.compiler import schedule from qiskit.circuit import QuantumCircuit from qiskit import pulse from qiskit.providers.fake_provider import GenericBackendV2 backend = GenericBackendV2(num_qubits=5, calibrate_instructions=True) d2 = pulse.DriveChannel(2) qc = QuantumCircuit(2) # Hadamard qc.rz(pi/2, 0) qc.sx(0) qc.rz(pi/2, 0) qc.cx(0, 1) bell_sched = schedule(qc, backend) with pulse.build(backend) as decoupled_bell_prep_and_measure: # We call our bell state preparation schedule constructed above. with pulse.align_right(): pulse.call(bell_sched) pulse.play(pulse.Constant(bell_sched.duration, 0.02), d2) pulse.barrier(0, 1, 2) registers = pulse.measure_all() decoupled_bell_prep_and_measure.draw() With the pulse builder we are able to blend programming on qubits and channels. While the pulse schedule is based on instructions that operate on channels, the pulse builder automatically handles the mapping from qubits to channels for you. In the example below we demonstrate some more features of the pulse builder: .. code-block:: import math from qiskit.compiler import schedule from qiskit import pulse, QuantumCircuit from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() qc = QuantumCircuit(2, 2) qc.cx(0, 1) with pulse.build(backend) as pulse_prog: # Create a pulse. gaussian_pulse = pulse.Gaussian(10, 1.0, 2) # Get the qubit's corresponding drive channel from the backend. d0 = pulse.drive_channel(0) d1 = pulse.drive_channel(1) # Play a pulse at t=0. pulse.play(gaussian_pulse, d0) # Play another pulse directly after the previous pulse at t=10. pulse.play(gaussian_pulse, d0) # The default scheduling behavior is to schedule pulses in parallel # across channels. For example, the statement below # plays the same pulse on a different channel at t=0. pulse.play(gaussian_pulse, d1) # We also provide pulse scheduling alignment contexts. # The default alignment context is align_left. # The sequential context schedules pulse instructions sequentially in time. # This context starts at t=10 due to earlier pulses above. with pulse.align_sequential(): pulse.play(gaussian_pulse, d0) # Play another pulse after at t=20. pulse.play(gaussian_pulse, d1) # We can also nest contexts as each instruction is # contained in its local scheduling context. # The output of a child context is a context-schedule # with the internal instructions timing fixed relative to # one another. This is schedule is then called in the parent context. # Context starts at t=30. with pulse.align_left(): # Start at t=30. pulse.play(gaussian_pulse, d0) # Start at t=30. pulse.play(gaussian_pulse, d1) # Context ends at t=40. # Alignment context where all pulse instructions are # aligned to the right, ie., as late as possible. with pulse.align_right(): # Shift the phase of a pulse channel. pulse.shift_phase(math.pi, d1) # Starts at t=40. pulse.delay(100, d0) # Ends at t=140. # Starts at t=130. pulse.play(gaussian_pulse, d1) # Ends at t=140. # Acquire data for a qubit and store in a memory slot. pulse.acquire(100, 0, pulse.MemorySlot(0)) # We also support a variety of macros for common operations. # Measure all qubits. pulse.measure_all() # Delay on some qubits. # This requires knowledge of which channels belong to which qubits. # delay for 100 cycles on qubits 0 and 1. pulse.delay_qubits(100, 0, 1) # Call a schedule for a quantum circuit thereby inserting into # the pulse schedule. qc = QuantumCircuit(2, 2) qc.cx(0, 1) qc_sched = schedule(qc, backend) pulse.call(qc_sched) # It is also be possible to call a preexisting schedule tmp_sched = pulse.Schedule() tmp_sched += pulse.Play(gaussian_pulse, d0) pulse.call(tmp_sched) # We also support: # frequency instructions pulse.set_frequency(5.0e9, d0) # phase instructions pulse.shift_phase(0.1, d0) # offset contexts with pulse.phase_offset(math.pi, d0): pulse.play(gaussian_pulse, d0) The above is just a small taste of what is possible with the builder. See the rest of the module documentation for more information on its capabilities. .. autofunction:: build Channels ======== Methods to return the correct channels for the respective qubit indices. .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import GenericBackendV2 backend = GenericBackendV2(num_qubits=2, calibrate_instructions=True) with pulse.build(backend) as drive_sched: d0 = pulse.drive_channel(0) print(d0) .. code-block:: text DriveChannel(0) .. autofunction:: acquire_channel .. autofunction:: control_channels .. autofunction:: drive_channel .. autofunction:: measure_channel Instructions ============ Pulse instructions are available within the builder interface. Here's an example: .. plot:: :alt: Output from the previous code. :include-source: from qiskit import pulse from qiskit.providers.fake_provider import GenericBackendV2 backend = GenericBackendV2(num_qubits=2, calibrate_instructions=True) with pulse.build(backend) as drive_sched: d0 = pulse.drive_channel(0) a0 = pulse.acquire_channel(0) pulse.play(pulse.Constant(10, 1.0), d0) pulse.delay(20, d0) pulse.shift_phase(3.14/2, d0) pulse.set_phase(3.14, d0) pulse.shift_frequency(1e7, d0) pulse.set_frequency(5e9, d0) with pulse.build() as temp_sched: pulse.play(pulse.Gaussian(20, 1.0, 3.0), d0) pulse.play(pulse.Gaussian(20, -1.0, 3.0), d0) pulse.call(temp_sched) pulse.acquire(30, a0, pulse.MemorySlot(0)) drive_sched.draw() .. autofunction:: acquire .. autofunction:: barrier .. autofunction:: call .. autofunction:: delay .. autofunction:: play .. autofunction:: reference .. autofunction:: set_frequency .. autofunction:: set_phase .. autofunction:: shift_frequency .. autofunction:: shift_phase .. autofunction:: snapshot Contexts ======== Builder aware contexts that modify the construction of a pulse program. For example an alignment context like :func:`align_right` may be used to align all pulses as late as possible in a pulse program. .. plot:: :alt: Output from the previous code. :include-source: from qiskit import pulse d0 = pulse.DriveChannel(0) d1 = pulse.DriveChannel(1) with pulse.build() as pulse_prog: with pulse.align_right(): # this pulse will start at t=0 pulse.play(pulse.Constant(100, 1.0), d0) # this pulse will start at t=80 pulse.play(pulse.Constant(20, 1.0), d1) pulse_prog.draw() .. autofunction:: align_equispaced .. autofunction:: align_func .. autofunction:: align_left .. autofunction:: align_right .. autofunction:: align_sequential .. autofunction:: frequency_offset .. autofunction:: phase_offset Macros ====== Macros help you add more complex functionality to your pulse program. .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import GenericBackendV2 backend = GenericBackendV2(num_qubits=2, calibrate_instructions=True) with pulse.build(backend) as measure_sched: mem_slot = pulse.measure(0) print(mem_slot) .. code-block:: text MemorySlot(0) .. autofunction:: measure .. autofunction:: measure_all .. autofunction:: delay_qubits Utilities ========= The utility functions can be used to gather attributes about the backend and modify how the program is built. .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import GenericBackendV2 backend = GenericBackendV2(num_qubits=2, calibrate_instructions=True) with pulse.build(backend) as u3_sched: print('Number of qubits in backend: {}'.format(pulse.num_qubits())) samples = 160 print('There are {} samples in {} seconds'.format( samples, pulse.samples_to_seconds(160))) seconds = 1e-6 print('There are {} seconds in {} samples.'.format( seconds, pulse.seconds_to_samples(1e-6))) .. code-block:: text Number of qubits in backend: 1 There are 160 samples in 3.5555555555555554e-08 seconds There are 1e-06 seconds in 4500 samples. .. autofunction:: active_backend .. autofunction:: num_qubits .. autofunction:: qubit_channels .. autofunction:: samples_to_seconds .. autofunction:: seconds_to_samples ) annotationsN) GeneratorCallableIterable)contextmanager)singledispatchmethod)TypeVarContextManager TypedDictUnionOptionalDict)ParameterExpressionParameterValueType)channels configuration exceptions instructionsmacroslibrary transforms) BackendV2) directives)Schedule ScheduleBlock) AlignmentKind)deprecate_pulse_func) )Unpackbackendz'contextvars.ContextVar['_PulseBuilder']BUILDER_CONTEXTVARTfunctionCallable[..., T]returncFtjfd}|S)z\Decorator a function to raise if it is called without a builder with a set backend. cR|jtjd|g|Ri|S)Nz;This function requires the builder to have a "backend" set.)r!r BackendNotSet)selfargskwargsr$s J/granary/edev/quantum/lib/python3.11/site-packages/qiskit/pulse/builder.pywrapperz"_requires_backend..wrappersE < *M x.t...v...) functoolswraps)r$r.s` r-_requires_backendr2s: _X///// Nr/ceZdZdZejejejdZ d0d1d Z d2dZ dZ e dZ d3dZd2dZd2dZe edZd2dZd4dZd5dZd6d Ze d7d8d%Zej d7d9d)Zej d7d:d,Zed;d.Zd/ZdS)< _PulseBuilderzBuilder context class.)leftright sequentialNr5blockScheduleBlock | Nonename str | Nonedefault_alignmentstr | AlignmentKindc ||_d|_g|_||_|t |t r|}nMt |t r||}n"tj d|j j d|j |t |tr|}n tj||}t |tsWtj dt#|ddtjd||dS)aInitialize the builder context. .. note:: At some point we may consider incorporating the builder into the :class:`~qiskit.pulse.Schedule` class. However, the risk of this is tying the user interface to the intermediate representation. For now we avoid this at the cost of some code duplication. Args: backend (Backend): Input backend to use in builder. If not set certain functionality will be unavailable. block: Initital ``ScheduleBlock`` to build on. name: Name of pulse program to be built. default_alignment: Default scheduling alignment for builder. One of ``left``, ``right``, ``sequential`` or an instance of :class:`~qiskit.pulse.transforms.alignments.AlignmentKind` subclass. Raises: PulseError: When invalid ``default_alignment`` or `block` is specified. NzInput `block` type z0 is not a valid format. Specify a pulse program.zGiven `default_alignment` z+ is not a valid transformation. Set one of , z1, or set an instance of `AlignmentKind` subclass.)_backend_backend_ctx_token_context_stack_name isinstancerr_naive_typecast_scheduler PulseError __class____name__appendrr4__alignment_kinds__getreprjoinkeys push_context)r*r!r8r:r< root_block alignments r-__init__z_PulseBuilder.__init__s:  LP46   %// " E8,, !::5AA  +C%/*BCCC   & &z 2 2 2 ' 7 7 d)II%9==>OQbccI)]33 'BT2C-D-DBB99]>CCEEFFBBB  )$$$$$r/r&rct||_|jd}|jp|j|_|S)zEnter this builder context and yield either the supplied schedule or the schedule created for the user. Returns: The schedule that the builder will build on. r)r"setrArBrCr:)r*outputs r- __enter__z_PulseBuilder.__enter__(s<#5"8"8">">$Q'z0V[  r/cl|t|jdS)z=Exit the builder context and compile the built pulse program.N)compiler"resetrA)r*exc_typeexc_valexc_tbs r-__exit__z_PulseBuilder.__exit__5s,   !899999r/c|jS)ztReturns the builder backend if set. Returns: Optional[Backend]: The builder's backend. )r@r*s r-r!z_PulseBuilder.backend:s }r/rQrcV|jt|dS)zPush new context to the stack.)alignment_contextN)rBrIr)r*rQs r-rOz_PulseBuilder.push_contextCs* ""=9#M#M#MNNNNNr/ct|jdkrtjd|jS)z$Pop the last context from the stack.z&The root context cannot be popped out.)lenrBrrFpopr_s r- pop_contextz_PulseBuilder.pop_contextGs? t" # #q ( ('(PQQ Q"&&(((r/c|jdS)zGet current context. Notes: New instruction can be added by `.append_subroutine` or `.append_instruction` method. Use above methods rather than directly accessing to the current context. )rBr_s r- get_contextz_PulseBuilder.get_contextNs"2&&r/ct|jtr |jjS|jjS)z(Get the number of qubits in the backend.)rDr!r num_qubitsrn_qubitsr_s r-rkz_PulseBuilder.num_qubitsWs: dlI . . +<* *|))++44r/ct|jdkrA|}||t|jdkA|jdS)z+Compile and output the built pulse program.rcr)rdrBrfappend_subroutine)r*currents r-rXz_PulseBuilder.compile`sg $%&&**&&((G  " "7 + + +$%&&**"1%%r/ instructioninstructions.InstructioncF|jd|dS)z}Add an instruction to the builder's context schedule. Args: instruction: Instruction to append. rhN)rBrI)r*rps r-append_instructionz _PulseBuilder.append_instructionls& B&&{33333r/str extra_keyscTtj|g|R}||dS)zAdd external program as a :class:`~qiskit.pulse.instructions.Reference` instruction. Args: name: Name of subroutine. extra_keys: Assistance keys to uniquely specify the subroutine. N)r Referencers)r*r:ruinsts r-append_referencez_PulseBuilder.append_referencets6%d8Z888 %%%%%r/ subroutineSchedule | ScheduleBlockc@t|ttfs"tjd|jjdt|dkrdSt|tr||}|j d |dS)a}Append a :class:`ScheduleBlock` to the builder's context schedule. This operation doesn't create a reference. Subroutine is directly appended to current context schedule. Args: subroutine: ScheduleBlock to append to the current context block. Raises: PulseError: When subroutine is not Schedule nor ScheduleBlock. 'zq' is not valid data format in the builder. 'Schedule' and 'ScheduleBlock' can be appended to the builder context.rNrh) rDrrrrFrGrHrdrErBrI)r*rzs r-rnz_PulseBuilder.append_subroutine~s*}h&?@@ 'YJ(1YYY  z??a   F j( + + C66zBBJ B&&z22222r/ value_dict4dict[ParameterExpression, ParameterValueType] | None kw_paramsrc Ftjd|jjd)axCall a schedule or circuit defined outside of the current scope. The ``subroutine`` is appended to the context schedule as a call instruction. This logic just generates a convenient program representation in the compiler. Thus, this doesn't affect execution of inline subroutines. See :class:`~pulse.instructions.Call` for more details. Args: subroutine: Target schedule or circuit to append to the current context. name: Name of subroutine if defined. value_dict: Parameter object and assigned value mapping. This is more precise way to identify a parameter since mapping is managed with unique object id rather than name. Especially there is any name collision in a parameter table. kw_params: Parameter values to bind to the target subroutine with string parameter names. If there are parameter name overlapping, these parameters are updated with the same assigned value. Raises: PulseError: - When input subroutine is not valid data format. zSubroutine type z; is not valid data format. Call Schedule, or ScheduleBlock.)rrFrGrH)r*rzr:r~rs r-call_subroutinez_PulseBuilder.call_subroutines5:# *z3< * * *   r/ target_block Optional[str]7Optional[Dict[ParameterExpression, ParameterValueType]]c t|dkrdSi}|D]l\}}||}|sFtjd|ddt t|jd|D]} ||| <m|rX| | zrtj dt| ||r||d}| |jt!jjf} n|f} |j| || |id dS) Nrz Parameter z* is not defined in the target subroutine. r?z can be specified.zSome parameters provided by 'value_dict' conflict with one through keyword arguments. Parameter values in the keyword arguments are overridden by the dictionary values.FinplaceT)rditemsget_parametersrrFrMmaprt parametersrNwarningswarn UserWarningupdateassign_parametersr:uuiduuid4hexryriassign_references) r*rr:r~rlocal_assignment param_namevalueparamsparamrNs r-_z_PulseBuilder._s |   ! ! F!*!2!2 0 0 J!00<.get_qubit_channels_v2s #/ 5 5K ##")"9"9+"F"F"5OOO444 --e44555//66777//66777r/)r!rrr)rDrrrTrget_qubit_channels)rrs r-qubit_channelsrs8*.""I..C(()9)95AABBB ~--//BB5II J JJr/channels_or_qubitsint | chans.Channelct}|D]p}t|tr|t|z}*t|tjr||Ztj|d|S)z0Returns the unique channels of the input qubits.z' is not a "Channel" or qubit (integer).) rTrDrrchansChanneladdrrF)rrchannel_or_qubits r-_qubits_to_channelsrsuuH. & , ,  '788 8HH (%- 8 8  LL) * * * *'#LLL  Or/Generator[None, None, None]c#*Kt}|tj dV|}||dS#|}||wxYw)a Left alignment pulse scheduling context. Pulse instructions within this context are scheduled as early as possible by shifting them left to the earliest available time. Examples: .. code-block:: from qiskit import pulse d0 = pulse.DriveChannel(0) d1 = pulse.DriveChannel(1) with pulse.build() as pulse_prog: with pulse.align_left(): # this pulse will start at t=0 pulse.play(pulse.Constant(100, 1.0), d0) # this pulse will start at t=0 pulse.play(pulse.Constant(20, 1.0), d1) pulse_prog = pulse.transforms.block_to_schedule(pulse_prog) assert pulse_prog.ch_start_time(d0) == pulse_prog.ch_start_time(d1) Yields: None N)rrOrrrfrnrros r- align_leftrs<G -//000+ %%''!!'*****%%''!!'**** A''+Bc#*Kt}|tj dV|}||dS#|}||wxYw)a Right alignment pulse scheduling context. Pulse instructions within this context are scheduled as late as possible by shifting them right to the latest available time. Examples: .. code-block:: from qiskit import pulse d0 = pulse.DriveChannel(0) d1 = pulse.DriveChannel(1) with pulse.build() as pulse_prog: with pulse.align_right(): # this pulse will start at t=0 pulse.play(pulse.Constant(100, 1.0), d0) # this pulse will start at t=80 pulse.play(pulse.Constant(20, 1.0), d1) pulse_prog = pulse.transforms.block_to_schedule(pulse_prog) assert pulse_prog.ch_stop_time(d0) == pulse_prog.ch_stop_time(d1) Yields: None N)rrOrrrfrnrs r- align_rightr6s<G .00111+ %%''!!'*****%%''!!'****rc#*Kt}|tj dV|}||dS#|}||wxYw)a(Sequential alignment pulse scheduling context. Pulse instructions within this context are scheduled sequentially in time such that no two instructions will be played at the same time. Examples: .. code-block:: from qiskit import pulse d0 = pulse.DriveChannel(0) d1 = pulse.DriveChannel(1) with pulse.build() as pulse_prog: with pulse.align_sequential(): # this pulse will start at t=0 pulse.play(pulse.Constant(100, 1.0), d0) # this pulse will also start at t=100 pulse.play(pulse.Constant(20, 1.0), d1) pulse_prog = pulse.transforms.block_to_schedule(pulse_prog) assert pulse_prog.ch_stop_time(d0) == pulse_prog.ch_start_time(d1) Yields: None N)rrOrrrfrnrs r-align_sequentialr]s<G 355666+ %%''!!'*****%%''!!'****rdurationint | ParameterExpressionc#.Kt}|tj| dV|}||dS#|}||wxYw)aEquispaced alignment pulse scheduling context. Pulse instructions within this context are scheduled with the same interval spacing such that the total length of the context block is ``duration``. If the total free ``duration`` cannot be evenly divided by the number of instructions within the context, the modulo is split and then prepended and appended to the returned schedule. Delay instructions are automatically inserted in between pulses. This context is convenient to write a schedule for periodical dynamic decoupling or the Hahn echo sequence. Examples: .. plot:: :alt: Output from the previous code. :include-source: from qiskit import pulse d0 = pulse.DriveChannel(0) x90 = pulse.Gaussian(10, 0.1, 3) x180 = pulse.Gaussian(10, 0.2, 3) with pulse.build() as hahn_echo: with pulse.align_equispaced(duration=100): pulse.play(x90, d0) pulse.play(x180, d0) pulse.play(x90, d0) hahn_echo.draw() Args: duration: Duration of this context. This should be larger than the schedule duration. Yields: None Notes: The scheduling is performed for sub-schedules within the context rather than channel-wise. If you want to apply the equispaced context for each channel, you should use the context independently for channels. )rN)rrOrAlignEquispacedrfrn)rrros r-align_equispacedrsZG 3XFFFGGG+ %%''!!'*****%%''!!'****s A))+BfuncCallable[[int], float]c#0Kt}|tj|| dV|}||dS#|}||wxYw)aCallback defined alignment pulse scheduling context. Pulse instructions within this context are scheduled at the location specified by arbitrary callback function `position` that takes integer index and returns the associated fractional location within [0, 1]. Delay instruction is automatically inserted in between pulses. This context may be convenient to write a schedule of arbitrary dynamical decoupling sequences such as Uhrig dynamical decoupling. Examples: .. plot:: :alt: Output from the previous code. :include-source: import numpy as np from qiskit import pulse d0 = pulse.DriveChannel(0) x90 = pulse.Gaussian(10, 0.1, 3) x180 = pulse.Gaussian(10, 0.2, 3) def udd10_pos(j): return np.sin(np.pi*j/(2*10 + 2))**2 with pulse.build() as udd_sched: pulse.play(x90, d0) with pulse.align_func(duration=300, func=udd10_pos): for _ in range(10): pulse.play(x180, d0) pulse.play(x90, d0) udd_sched.draw() Args: duration: Duration of context. This should be larger than the schedule duration. func: A function that takes an index of sub-schedule and returns the fractional coordinate of of that sub-schedule. The returned value should be defined within [0, 1]. The pulse index starts from 1. Yields: None Notes: The scheduling is performed for sub-schedules within the context rather than channel-wise. If you want to apply the numerical context for each channel, you need to apply the context independently to channels. )rrN)rrOr AlignFuncrfrn)rrrros r- align_funcrsnG -xdKKKLLL+ %%''!!'*****%%''!!'****s A**+Brarc#ZKt|tstjdt }|| dV|}||dS#|}||wxYw)aqArbitrary alignment transformation defined by a subclass instance of :class:`~qiskit.pulse.transforms.alignments.AlignmentKind`. Args: alignment_context: Alignment context instance that defines schedule transformation. Yields: None Raises: PulseError: When input ``alignment_context`` is not ``AlignmentKind`` subclasses. z8Input alignment context is not `AlignmentKind` subclass.N)rDrrrFrrOrfrn)rarros r-general_transformsrs ' 7 7`#$^___G *++++ %%''!!'*****%%''!!'****s A??+B*phasefloatrchans.PulseChannelc'K|D]}t|| dV|D]}t| |dS#|D]}t| |wxYw)aShift the phase of input channels on entry into context and undo on exit. Examples: .. code-block:: import math from qiskit import pulse d0 = pulse.DriveChannel(0) with pulse.build() as pulse_prog: with pulse.phase_offset(math.pi, d0): pulse.play(pulse.Constant(10, 1.0), d0) assert len(pulse_prog.instructions) == 3 Args: phase: Amount of phase offset in radians. channels: Channels to offset phase of. Yields: None N) shift_phase)rrchannels r- phase_offsetrs8$$E7####)  ) )G  ( ( ( ( ) )x ) )G  ( ( ( ( )s 5A F)compensate_phase frequencyrboolc'rKt}|j}|D]}t|| dV|r_|j|z }dtjz||z|zdzz}|D]}t| ||D]}t| |dS#|r_|j|z }dtjz||z|zdzz}|D]}t| ||D]}t| |wxYw)aShift the frequency of inputs channels on entry into context and undo on exit. Examples: .. code-block:: python :emphasize-lines: 7, 16 from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() d0 = pulse.DriveChannel(0) with pulse.build(backend) as pulse_prog: # shift frequency by 1GHz with pulse.frequency_offset(1e9, d0): pulse.play(pulse.Constant(10, 1.0), d0) assert len(pulse_prog.instructions) == 3 with pulse.build(backend) as pulse_prog: # Shift frequency by 1GHz. # Undo accumulated phase in the shifted frequency frame # when exiting the context. with pulse.frequency_offset(1e9, d0, compensate_phase=True): pulse.play(pulse.Constant(10, 1.0), d0) assert len(pulse_prog.instructions) == 4 Args: frequency: Amount of frequency offset in Hz. channels: Channels to offset frequency of. compensate_phase: Compensate for accumulated phase accumulated with respect to the channels' frame at its initial frequency. Yields: None Nrc)rrirshift_frequencyrpirr)rrrrt0rraccumulated_phases r-frequency_offsetr9sVG      'B,, 7++++ 1   9**,,5:H !BE h9I9I.II.UYZ-Z [ # 9 9..8888 1 1G YJ 0 0 0 0 1 1  9**,,5:H !BE h9I9I.II.UYZ-Z [ # 9 9..8888 1 1G YJ 0 0 0 0 1s B==A9D6chans.DriveChannelctttr!t|St|S)aReturn ``DriveChannel`` for ``qubit`` on the active builder backend. Examples: .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() with pulse.build(backend): assert pulse.drive_channel(0) == pulse.DriveChannel(0) .. note:: Requires the active builder context to have a backend set. )rDrrrrdrivers r-rr|s\&.""I..5--e444    ) ) + + 1 1% 8 88r/chans.MeasureChannelctttr!t|St|S)aReturn ``MeasureChannel`` for ``qubit`` on the active builder backend. Examples: .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() with pulse.build(backend): assert pulse.measure_channel(0) == pulse.MeasureChannel(0) .. note:: Requires the active builder context to have a backend set. )rDrrrrmeasurers r-rr\&.""I..7//666    ) ) + + 3 3E : ::r/chans.AcquireChannelctttr!t|St|S)aReturn ``AcquireChannel`` for ``qubit`` on the active builder backend. Examples: .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() with pulse.build(backend): assert pulse.acquire_channel(0) == pulse.AcquireChannel(0) .. note:: Requires the active builder context to have a backend set. )rDrrrracquirers r-rrrr/qubits Iterable[int]list[chans.ControlChannel]ctttr!t|St|S)a Return ``ControlChannel`` for ``qubit`` on the active builder backend. Return the secondary drive channel for the given qubit -- typically utilized for controlling multi-qubit interactions. Examples: .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() with pulse.build(backend): assert pulse.control_channels(0, 1) == [pulse.ControlChannel(0)] .. note:: Requires the active builder context to have a backend set. Args: qubits: Tuple or list of ordered qubits of the form `(control_qubit, target_qubit)`. Returns: List of control channels associated with the supplied ordered list of qubits. r)rDrrrrcontrolr s r-control_channelsr"s_:.""I..8//777    ) ) + + 3 36 3 B BBr/r chans.ChannelcNttj|||dS)a|Delay on a ``channel`` for a ``duration``. Examples: .. code-block:: from qiskit import pulse d0 = pulse.DriveChannel(0) with pulse.build() as pulse_prog: pulse.delay(10, d0) Args: duration: Number of cycles to delay for on ``channel``. channel: Channel to delay on. name: Name of the instruction. rN)rsrDelay)rrr:s r-delayr&s*(|)(G$GGGHHHHHr/pulselibrary.Pulse | np.ndarrayct|tjstj|}t t j|||dS)aePlay a ``pulse`` on a ``channel``. Examples: .. code-block:: from qiskit import pulse d0 = pulse.DriveChannel(0) with pulse.build() as pulse_prog: pulse.play(pulse.Constant(10, 1.0), d0) Args: pulse: Pulse to play. channel: Channel to play pulse on. name: Name of the pulse. rN)rDrPulseWaveformrsrPlay)r'rr:s r-playr-sN( eW] + +( ''|(dCCCDDDDDr/cBeZdZUded<ded<ded<ded<d ed <d S) _MetaDataTypezconfiguration.Kernelkernelzconfiguration.Discriminator discriminatorzchans.MemorySlotmem_slotzchans.RegisterSlotreg_slotrtr:N)rHrr__annotations__rr/r-r/r/sI    ....     IIIIIr/r/)totalqubit_or_channelint | chans.AcquireChannelrStorageLocationmetadataUnpack[_MetaDataType]c t|trtj|}t|tjr$t t j||fd|i|dSt|tjr$t t j||fd|i|dStj dt|d)a"Acquire for a ``duration`` on a ``channel`` and store the result in a ``register``. Examples: .. code-block:: from qiskit import pulse acq0 = pulse.AcquireChannel(0) mem0 = pulse.MemorySlot(0) with pulse.build() as pulse_prog: pulse.acquire(100, acq0, mem0) # measurement metadata kernel = pulse.configuration.Kernel('linear_discriminator') pulse.acquire(100, acq0, mem0, kernel=kernel) .. note:: The type of data acquire will depend on the execution ``meas_level``. Args: duration: Duration to acquire data for qubit_or_channel: Either the qubit to acquire data for or the specific :class:`~qiskit.pulse.channels.AcquireChannel` to acquire on. register: Location to store measured result. metadata: Additional metadata for measurement. See :class:`~qiskit.pulse.instructions.Acquire` for more information. Raises: exceptions.PulseError: If the register type is not supported. r2r3zRegister of type: "z" is not supportedN) rDrrAcquireChannel MemorySlotrsrAcquire RegisterSlotrrFtype)rr6rr9s r-rr sN"C((B /0@AA(E,-- ^  +; [ [h [RZ [ [      He0 1 1^  +; [ [h [RZ [ [     #$\$x..$\$\$\]]]r/cNttj|||dS)aSet the ``frequency`` of a pulse ``channel``. Examples: .. code-block:: from qiskit import pulse d0 = pulse.DriveChannel(0) with pulse.build() as pulse_prog: pulse.set_frequency(1e9, d0) Args: frequency: Frequency in Hz to set channel to. channel: Channel to set frequency of. name: Name of the instruction. rN)rsr SetFrequencyrrr:s r- set_frequencyrDVs*(|0G$OOOPPPPPr/cNttj|||dS)aShift the ``frequency`` of a pulse ``channel``. Examples: .. code-block:: python :emphasize-lines: 6 from qiskit import pulse d0 = pulse.DriveChannel(0) with pulse.build() as pulse_prog: pulse.shift_frequency(1e9, d0) Args: frequency: Frequency in Hz to shift channel frequency by. channel: Channel to shift frequency of. name: Name of the instruction. rN)rsrShiftFrequencyrCs r-r r ms**|29gDQQQRRRRRr/cNttj|||dS)aSet the ``phase`` of a pulse ``channel``. Examples: .. code-block:: python :emphasize-lines: 8 import math from qiskit import pulse d0 = pulse.DriveChannel(0) with pulse.build() as pulse_prog: pulse.set_phase(math.pi, d0) Args: phase: Phase in radians to set channel carrier signal to. channel: Channel to set phase of. name: Name of the instruction. rN)rsrSetPhaserrr:s r- set_phaserJs*.|,UG$GGGHHHHHr/cLttj|||dS)aShift the ``phase`` of a pulse ``channel``. Examples: .. code-block:: import math from qiskit import pulse d0 = pulse.DriveChannel(0) with pulse.build() as pulse_prog: pulse.shift_phase(math.pi, d0) Args: phase: Phase in radians to shift channel carrier signal by. channel: Channel to shift phase of. name: Name of the instruction. N)rsr ShiftPhaserIs r-rrs',|.ugtDDEEEEEr/ statevectorlabelrt snapshot_typecLttj||dS)aSimulator snapshot. Examples: .. code-block:: from qiskit import pulse with pulse.build() as pulse_prog: pulse.snapshot('first', 'statevector') Args: label: Label for snapshot. snapshot_type: Type of snapshot. )rON)rsrSnapshot)rNrOs r-snapshotrRs("|,U-PPPQQQQQr/targetSchedule | ScheduleBlock | Noner~3dict[ParameterValueType, ParameterValueType] | Nonerrc >tj|||fi|dS)a<Call the subroutine within the currently active builder context with arbitrary parameters which will be assigned to the target program. .. note:: If the ``target`` program is a :class:`.ScheduleBlock`, then a :class:`.Reference` instruction will be created and appended to the current context. The ``target`` program will be immediately assigned to the current scope as a subroutine. If the ``target`` program is :class:`.Schedule`, it will be wrapped by the :class:`.Call` instruction and appended to the current context to avoid a mixed representation of :class:`.ScheduleBlock` and :class:`.Schedule`. If the ``target`` program is a :class:`.QuantumCircuit` it will be scheduled and the new :class:`.Schedule` will be added as a :class:`.Call` instruction. Examples: 1. Calling a schedule block (recommended) .. code-block:: from qiskit import circuit, pulse from qiskit.providers.fake_provider import GenericBackendV2 backend = GenericBackendV2(num_qubits=5, calibrate_instructions=True) with pulse.build() as x_sched: pulse.play(pulse.Gaussian(160, 0.1, 40), pulse.DriveChannel(0)) with pulse.build() as pulse_prog: pulse.call(x_sched) print(pulse_prog) .. code-block:: text ScheduleBlock( ScheduleBlock( Play( Gaussian(duration=160, amp=(0.1+0j), sigma=40), DriveChannel(0) ), name="block0", transform=AlignLeft() ), name="block1", transform=AlignLeft() ) The actual program is stored in the reference table attached to the schedule. .. code-block:: print(pulse_prog.references) .. code-block:: text ReferenceManager: - ('block0', '634b3b50bd684e26a673af1fbd2d6c81'): ScheduleBlock(Play(Gaussian(... In addition, you can call a parameterized target program with parameter assignment. .. code-block:: amp = circuit.Parameter("amp") with pulse.build() as subroutine: pulse.play(pulse.Gaussian(160, amp, 40), pulse.DriveChannel(0)) with pulse.build() as pulse_prog: pulse.call(subroutine, amp=0.1) pulse.call(subroutine, amp=0.3) print(pulse_prog) .. code-block:: text ScheduleBlock( ScheduleBlock( Play( Gaussian(duration=160, amp=(0.1+0j), sigma=40), DriveChannel(0) ), name="block2", transform=AlignLeft() ), ScheduleBlock( Play( Gaussian(duration=160, amp=(0.3+0j), sigma=40), DriveChannel(0) ), name="block2", transform=AlignLeft() ), name="block3", transform=AlignLeft() ) If there is a name collision between parameters, you can distinguish them by specifying each parameter object in a python dictionary. For example, .. code-block:: amp1 = circuit.Parameter('amp') amp2 = circuit.Parameter('amp') with pulse.build() as subroutine: pulse.play(pulse.Gaussian(160, amp1, 40), pulse.DriveChannel(0)) pulse.play(pulse.Gaussian(160, amp2, 40), pulse.DriveChannel(1)) with pulse.build() as pulse_prog: pulse.call(subroutine, value_dict={amp1: 0.1, amp2: 0.3}) print(pulse_prog) .. code-block:: text ScheduleBlock( ScheduleBlock( Play(Gaussian(duration=160, amp=(0.1+0j), sigma=40), DriveChannel(0)), Play(Gaussian(duration=160, amp=(0.3+0j), sigma=40), DriveChannel(1)), name="block4", transform=AlignLeft() ), name="block5", transform=AlignLeft() ) 2. Calling a schedule .. code-block:: x_sched = backend.instruction_schedule_map.get("x", (0,)) with pulse.build(backend) as pulse_prog: pulse.call(x_sched) print(pulse_prog) .. code-block:: text ScheduleBlock( Call( Schedule( ( 0, Play( Drag( duration=160, amp=(0.18989731546729305+0j), sigma=40, beta=-1.201258305015517, name='drag_86a8' ), DriveChannel(0), name='drag_86a8' ) ), name="x" ), name='x' ), name="block6", transform=AlignLeft() ) Currently, the backend calibrated gates are provided in the form of :class:`~.Schedule`. The parameter assignment mechanism is available also for schedules. However, the called schedule is not treated as a reference. Args: target: Target circuit or pulse schedule to call. name: Optional. A unique name of subroutine if defined. When the name is explicitly provided, one cannot call different schedule blocks with the same name. value_dict: Optional. Parameters assigned to the ``target`` program. If this dictionary is provided, the ``target`` program is copied and then stored in the main built schedule and its parameters are assigned to the given values. This dictionary is keyed on :class:`~.Parameter` objects, allowing parameter name collision to be avoided. kw_params: Alternative way to provide parameters. Since this is keyed on the string parameter name, the parameters having the same name are all updated together. If you want to avoid name collision, use ``value_dict`` with :class:`~.Parameter` objects instead. N)rr)rSr:r~rs r-callrWs0@&O%fdJLL)LLLLLr/ruc:tj|g|RdS)aRefer to undefined subroutine by string keys. A :class:`~qiskit.pulse.instructions.Reference` instruction is implicitly created and a schedule can be separately registered to the reference at a later stage. .. code-block:: python from qiskit import pulse with pulse.build() as main_prog: pulse.reference("x_gate", "q0") with pulse.build() as subroutine: pulse.play(pulse.Gaussian(160, 0.1, 40), pulse.DriveChannel(0)) main_prog.assign_references(subroutine_dict={("x_gate", "q0"): subroutine}) Args: name: Name of subroutine. extra_keys: Helper keys to uniquely specify the subroutine. N)rry)r:rus r- referencerYs+.'O&t9j999999r/rchans.Channel | intc~t|}t|dkr ttj|d|idSdS)a Barrier directive for a set of channels and qubits. This directive prevents the compiler from moving instructions across the barrier. Consider the case where we want to enforce that one pulse happens after another on separate channels, this can be done with: .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() d0 = pulse.DriveChannel(0) d1 = pulse.DriveChannel(1) with pulse.build(backend) as barrier_pulse_prog: pulse.play(pulse.Constant(10, 1.0), d0) pulse.barrier(d0, d1) pulse.play(pulse.Constant(10, 1.0), d1) Of course this could have been accomplished with: .. code-block:: from qiskit.pulse import transforms with pulse.build(backend) as aligned_pulse_prog: with pulse.align_sequential(): pulse.play(pulse.Constant(10, 1.0), d0) pulse.play(pulse.Constant(10, 1.0), d1) barrier_pulse_prog = transforms.target_qobj_transform(barrier_pulse_prog) aligned_pulse_prog = transforms.target_qobj_transform(aligned_pulse_prog) assert barrier_pulse_prog == aligned_pulse_prog The barrier allows the pulse compiler to take care of more advanced scheduling alignment operations across channels. For example in the case where we are calling an outside circuit or schedule and want to align a pulse at the end of one call: .. code-block:: import math from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() d0 = pulse.DriveChannel(0) with pulse.build(backend) as pulse_prog: with pulse.align_right(): pulse.call(backend.defaults().instruction_schedule_map.get('u1', (1,))) # Barrier qubit 1 and d0. pulse.barrier(1, d0) # Due to barrier this will play before the gate on qubit 1. pulse.play(pulse.Constant(10, 1.0), d0) # This will end at the same time as the pulse above due to # the barrier. pulse.call(backend.defaults().instruction_schedule_map.get('u1', (1,))) .. note:: Requires the active builder context to have a backend set if qubits are barriered on. Args: channels_or_qubits: Channels or qubits to barrier. name: Name for the barrier rcr:N)rrdrsrRelativeBarrier)r:rrs r-barrierr]sMP#$67H 8}}q:5xKdKKLLLLLr/rctdttjfd}|S)aWrap a Python function and activate the parent builder context at calling time. This enables embedding Python functions as builder macros. This generates a new :class:`pulse.Schedule` that is embedded in the parent builder context with every call of the decorated macro function. The decorated macro function will behave as if the function code was embedded inline in the parent builder context after parameter substitution. Examples: .. plot:: :alt: Output from the previous code. :include-source: from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q @pulse.macro def measure(qubit: int): pulse.play(pulse.GaussianSquare(16384, 256, 15872), pulse.measure_channel(qubit)) mem_slot = pulse.MemorySlot(qubit) pulse.acquire(16384, pulse.acquire_channel(qubit), mem_slot) return mem_slot backend = FakeOpenPulse2Q() with pulse.build(backend=backend) as sched: mem_slot = measure(0) print(f"Qubit measured into {mem_slot}") sched.draw() Args: func: The Python function to enable as a builder macro. There are no requirements on the signature of the function, any calls to pulse builder methods will be added to builder context the wrapped function is called from. Returns: Callable: The wrapped ``func``. rHct}t|j5}|i|}dddn #1swxYwY|||S)N)r!r:)rrr!r)r+r,_builderbuiltrUr func_names r-r.zmacro..wrapper(s"$$ 8+) < < < +T4*6**F + + + + + + + + + + + + + + +   ''' s ;??)getattrrLr0r1)rr.rbs` @r-macrordsX\j$t**55I_T Nr/list[int] | int registers'list[StorageLocation] | StorageLocationc Dt} t|}n#t$r|g}YnwxYw| d|D}n$ t|}n#t$r|g}YnwxYwtj||dt ||D}dtt|}dd|D}t |d|d| t|d kr|d S|S) akMeasure a qubit within the currently active builder context. At the pulse level a measurement is composed of both a stimulus pulse and an acquisition instruction which tells the systems measurement unit to acquire data and process it. We provide this measurement macro to automate the process for you, but if desired full control is still available with :func:`acquire` and :func:`play`. To use the measurement it is as simple as specifying the qubit you wish to measure: .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse2Q backend = FakeOpenPulse2Q() qubit = 0 with pulse.build(backend) as pulse_prog: # Do something to the qubit. qubit_drive_chan = pulse.drive_channel(0) pulse.play(pulse.Constant(100, 1.0), qubit_drive_chan) # Measure the qubit. reg = pulse.measure(qubit) For now it is not possible to do much with the handle to ``reg`` but in the future we will support using this handle to a result register to build up ones program. It is also possible to supply this register: .. code-block:: with pulse.build(backend) as pulse_prog: pulse.play(pulse.Constant(100, 1.0), qubit_drive_chan) # Measure the qubit. mem0 = pulse.MemorySlot(0) reg = pulse.measure(qubit, mem0) assert reg == mem0 .. note:: Requires the active builder context to have a backend set. Args: qubits: Physical qubit to measure. registers: Register to store result in. If not selected the current behavior is to return the :class:`MemorySlot` with the same index as ``qubit``. This register will be returned. Returns: The ``register`` the qubit measurement result will be stored in. Nc6g|]}tj|Srrr=.0rs r- zmeasure..us#AAAU%e,,AAAr/c$i|] \}}||jSr)index)rlrrs r- zmeasure..~s ]]]?5(]]]r/rr!qubit_mem_slots&c3>K|]}t|jVdSN)rtro)rlrs r- zmeasure..s*<.s#===U!%((===r/ci|]}||Srrrks r-rpzmeasure_all..s:::%:::r/rq measure_allr)rrangerkrrrr)r!rrfr|s r-rrs6G :<< F==f===IN::6:::M%%m-%HHH r/cttjd|D}t 5|D]}t || ddddS#1swxYwYdS)aInsert delays on all the :class:`channels.Channel`\s that correspond to the input ``qubits`` at the same time. Examples: .. code-block:: from qiskit import pulse from qiskit.providers.fake_provider import FakeOpenPulse3Q backend = FakeOpenPulse3Q() with pulse.build(backend) as pulse_prog: # Delay for 100 cycles on qubits 0, 1 and 2. regs = pulse.delay_qubits(100, 0, 1, 2) .. note:: Requires the active builder context to have a backend set. Args: duration: Duration to delay for. qubits: Physical qubits to delay on. Delays will be inserted based on the channels returned by :func:`pulse.qubit_channels`. c34K|]}t|VdSru)rrks r-rwzdelay_qubits..s*3^3^eN54I4I3^3^3^3^3^3^r/N)rT itertoolschain from_iterablerr&)rr qubit_chanschans r- delay_qubitsrs2io333^3^W]3^3^3^^^__K "" " "D (D ! ! ! ! """""""""""""""""""sA))A-0A-)r$r%r&r%r)rr9r:r;r<rr&r)r&r4)rr{r)r&r)rrr&r)rrr&r)rrr&r)rrr&r)r&r)rrr&r)rrrrr&r)rarr&r)rrrrr&r)rrrrrr r&r)rrr&r)rrr&r)rrr&r)rrr&rru)rrrr#r:r;)r'r(rrr:r;)rrr6r7rr8r9r:)rrrrr:r;)rrrrr:r;)rM)rNrtrOrtr)rSrTr:r;r~rUrrr)rrZr:r;)rr)rrerfrgr&rg)r&r)rrrr)br __future__r contextvarsr0rsysrrcollections.abcrrr contextlibrrtypingr r r r r rnumpyr"qiskit.circuit.parameterexpressionrr qiskit.pulserrrrrrrrqiskit.providers.backendrqiskit.pulse.instructionsrqiskit.pulse.schedulerr"qiskit.pulse.transforms.alignmentsrqiskit.utils.deprecate_pulser version_infor typing_extensions ContextVarr"r4r#r=r?r8r2r4rrrrrsrkrrrrrrrrrrrrrrrr"r&r-r/rrDr rJrrRrWrYr]rdrrrrr/r-rs<RRRf #""""" 9999999999%%%%%%******LLLLLLLLLLLLLLLLVVVVVVVV/.....00000099999999<<<<<<======w((((((?Uk>TU^>_>_____ GCLL(%*<<=     o/o/o/o/o/o/o/o/d  %)4: /////j($22226666.55554$ 0 0 0 02K2K2K2Kj    $"+"+"+"+J"+"+"+"+J"+"+"+"+J1+1+1+1+h;+;+;+;+|++++2 ) ) ) )FNS=1=1=1=1=1=1B9999.;;;;.;;;;.CCCCDIIIII,EEEEE2IU2^2^2^2^jQQQQQ,SSSSS.IIIII2FFFFF0RRRRR&FJMMMMMD::::4IMIMIMIMIMIMIMZ::::z:>UUUUUp((((V""""""r/