One- and Two-Qubit Randomized Benchmarking in LabOne Q with Qiskit¶

In this notebook, we'll use the Qiskit Experiment Library to generate one and two qubit randomized benchmarking experiments. We'll then export the generated experiment to OpenQASM, import these OpenQASM experiments into LabOne Q, compile, and simulate the output signals.

When generating randomized benchmarking experiments in Qiskit, it will return a list of quantum circuits with the specified parameters. We show here how to efficiently import, compile and execute such a list into LabOne Q, resulting in a single, large experiment.

Imports¶

In [1]:

from __future__ import annotations

# LabOne Q:
# additional imports
# device setup and descriptor
from laboneq import openqasm3
from laboneq.contrib.example_helpers.generate_device_setup import (
    generate_device_setup_qubits,
)

# plotting functionality
from laboneq.contrib.example_helpers.plotting.plot_helpers import plot_simulation

# core LabOne Q functionality
from laboneq.simple import *

# qiskit
from qiskit import qasm3, transpile
from qiskit_experiments.library import randomized_benchmarking

from __future__ import annotations # LabOne Q: # additional imports # device setup and descriptor from laboneq import openqasm3 from laboneq.contrib.example_helpers.generate_device_setup import ( generate_device_setup_qubits, ) # plotting functionality from laboneq.contrib.example_helpers.plotting.plot_helpers import plot_simulation # core LabOne Q functionality from laboneq.simple import * # qiskit from qiskit import qasm3, transpile from qiskit_experiments.library import randomized_benchmarking

Define the Experimental Setup¶

Below, we generate a pre-calibrated experimental setup containing a DeviceSetup, Transmon qubits and a Session to run the experiments.

In [2]:

# specify the number of qubits you want to use
number_of_qubits = 2

# generate the device setup and the qubit objects using a helper function
device_setup, qubits = generate_device_setup_qubits(
    number_qubits=number_of_qubits,
    pqsc=[{"serial": "DEV10001"}],
    hdawg=[{"serial": "DEV8001", "zsync": 0, "number_of_channels": 8, "options": None}],
    shfqc=[
        {
            "serial": "DEV12001",
            "zsync": 1,
            "number_of_channels": 6,
            "readout_multiplex": 6,
            "options": None,
        }
    ],
    include_flux_lines=True,
    server_host="localhost",
    setup_name=f"my_{number_of_qubits}_tuneable_qubit_setup",
)

q0, q1 = qubits[:2]

# specify the number of qubits you want to use number_of_qubits = 2 # generate the device setup and the qubit objects using a helper function device_setup, qubits = generate_device_setup_qubits( number_qubits=number_of_qubits, pqsc=[{"serial": "DEV10001"}], hdawg=[{"serial": "DEV8001", "zsync": 0, "number_of_channels": 8, "options": None}], shfqc=[ { "serial": "DEV12001", "zsync": 1, "number_of_channels": 6, "readout_multiplex": 6, "options": None, } ], include_flux_lines=True, server_host="localhost", setup_name=f"my_{number_of_qubits}_tuneable_qubit_setup", ) q0, q1 = qubits[:2]

In [3]:

# create and connect to Session

# use emulation mode - no connection to instruments
use_emulation = True

my_session = Session(device_setup=device_setup)
my_session.connect(do_emulation=use_emulation, reset_devices=True)

# create and connect to Session # use emulation mode - no connection to instruments use_emulation = True my_session = Session(device_setup=device_setup) my_session.connect(do_emulation=use_emulation, reset_devices=True)

[2024.12.19 17:10:18.433] INFO    Logging initialized from [Default inline config in laboneq.laboneq_logging] logdir is /builds/qccs/laboneq-applications/docs/sources/how-to-guides/sources/04_qasm/laboneq_output/log

[2024.12.19 17:10:18.435] INFO    VERSION: laboneq 2.43.0

[2024.12.19 17:10:18.437] INFO    Connecting to data server at localhost:8004

[2024.12.19 17:10:18.440] INFO    Connected to Zurich Instruments LabOne Data Server version 24.10 at localhost:8004

[2024.12.19 17:10:18.441] WARNING HDAWG:dev8001: Include the device options 'HDAWG8/MF/ME/SKW/PC' in the device setup ('options' field of the 'instruments' list in the device setup descriptor, 'device_options' argument when constructing instrument objects to be added to 'DeviceSetup' instances). This will become a strict requirement in the future.

[2024.12.19 17:10:18.443] WARNING SHFQC/QA:dev12001: Include the device options 'SHFQC/QC6CH' in the device setup ('options' field of the 'instruments' list in the device setup descriptor, 'device_options' argument when constructing instrument objects to be added to 'DeviceSetup' instances). This will become a strict requirement in the future.

[2024.12.19 17:10:18.444] INFO    Configuring the device setup

[2024.12.19 17:10:18.495] INFO    The device setup is configured

Out[3]:

<laboneq.dsl.session.ConnectionState at 0x7b89349d9400>

Defining the QPU and Quantum Operations¶

Here, we define the QPU and the class of quantum operations corresponding to the gates in our QASM programs for Randomized Benchmarking produced with Qiskit.

To learn more about quantum operations, check out these pages in the LabOne Q User's Manual, here and here. To learn more about the QPU, have a look at this page.

In [4]:

class QASMOperations(dsl.QuantumOperations):
    """Class implementing the collection of quantum operations.

    Operations for the QASM RB experiments created by Qiskit.
    """

    QUBIT_TYPES = Transmon

    @dsl.quantum_operation
    def delay(self, q: Transmon, time: float) -> None:
        """A delay operation on the drive signal of the qubit."""
        dsl.delay(q.signals["drive"], time=time)

    @dsl.quantum_operation
    def x(
        self,
        q: Transmon,
        amplitude_scale: float = 1.0,
        amplitude: float | None = None,
        label: str = "x",
    ) -> None:
        """A drag pulse implementing an x rotation.

        The pulse length and amplitude are taken from the qubit parameters.
        """
        pulse_parameters = {"function": "drag"}
        x_pulse = dsl.create_pulse(pulse_parameters, name=f"{q.uid}_{label}")
        if amplitude is None:
            amplitude = amplitude_scale * q.parameters.user_defined["amplitude_pi"]
        dsl.play(
            q.signals["drive"],
            amplitude=amplitude,
            length=q.parameters.user_defined["pulse_length"],
            pulse=x_pulse,
        )

    @dsl.quantum_operation
    def sx(self, q: Transmon) -> None:
        """An sx operation used in the RB decomposition.

        Calls the x operation with a fixed amplitude_scale of 0.5.
        """
        self.x.omit_section(q, amplitude_scale=0.5, label="sx")

    @dsl.quantum_operation
    def rz(self, q: Transmon, angle: float) -> None:
        """An operation implementing a z rotation by the given angle."""
        dsl.play(
            signal=q.signals["drive"],
            pulse=None,
            increment_oscillator_phase=angle,
        )

    @dsl.quantum_operation
    def measure(self, q: Transmon, handle: str) -> None:
        """An operation implementing a qubit measurement.

        The results are stored under the name given by handle. The readout
        and integration parameters are taken from the qubit.
        """
        ro_pulse_parameters = {"function": "gaussian_square", "zero_boundaries": True}
        ro_pulse = dsl.create_pulse(ro_pulse_parameters, name=f"{q.uid}_readout_pulse")
        int_pulse_parameters = {"function": "const"}
        kernels = [
            dsl.create_pulse(int_pulse_parameters, name=f"{q.uid}_integration_kernel")
        ]
        dsl.measure(
            measure_signal=q.signals["measure"],
            measure_pulse_amplitude=q.parameters.user_defined["readout_amplitude"],
            measure_pulse_length=q.parameters.user_defined["readout_length"],
            measure_pulse=ro_pulse,
            handle=handle,
            acquire_signal=q.signals["acquire"],
            integration_kernel=kernels,
            integration_length=q.parameters.user_defined["readout_length"],
            reset_delay=None,
        )

    @dsl.quantum_operation
    def reset(self, q: Transmon) -> None:
        """An operation implementing active reset on a qubit."""
        handle = f"{q.uid}_qubit_state"
        self.measure(q, handle=handle)
        self.delay(q, q.parameters.user_defined["reset_delay_length"])
        with dsl.match(name=f"match_{q.uid}", handle=handle):
            with dsl.case(name=f"case_{q.uid}_g", state=0):
                pass
            with dsl.case(name=f"case_{q.uid}_e", state=1):
                self.x.omit_section(q)

    @dsl.quantum_operation
    def cx(self, q_control: Transmon, q_target: Transmon) -> None:
        """An operation implementing a cx gate on two qubits.

        The controlled X gate is implemented using a cross-resonance gate.
        """
        cx_id = f"cx_{q_control.uid}_{q_target.uid}"

        # define cancellation pulses for target and control
        cancellation_control_n = dsl.create_pulse(
            {"function": "gaussian_square"}, name="CR-"
        )
        cancellation_control_p = dsl.create_pulse(
            {"function": "gaussian_square"}, name="CR+"
        )
        cancellation_target_p = dsl.create_pulse(
            {"function": "gaussian_square"}, name="q1+"
        )
        cancellation_target_n = dsl.create_pulse(
            {"function": "gaussian_square"}, name="q1-"
        )

        # play X pulses on both target and control
        with dsl.section(name=f"{cx_id}_x_both") as x180_both:
            self.x(q_control, label="x180")
            self.x(q_target, label="x180")

        # First cross-resonance component
        with dsl.section(
            name=f"{cx_id}_canc_p", play_after=x180_both.uid
        ) as cancellation_p:
            dsl.play(signal=q_target.signals["drive"], pulse=cancellation_target_p)
            dsl.play(signal=q_control.signals["flux"], pulse=cancellation_control_n)

        # play X pulse on control
        x180_control = self.x(q_control, label="x180")
        x180_control.play_after = cancellation_p.uid

        # Second cross-resonance component
        with dsl.section(
            name=f"cx_{cx_id}_canc_n", play_after=x180_control.uid
        ):
            dsl.play(signal=q_target.signals["drive"], pulse=cancellation_target_n)
            dsl.play(signal=q_control.signals["flux"], pulse=cancellation_control_p)

class QASMOperations(dsl.QuantumOperations): """Class implementing the collection of quantum operations. Operations for the QASM RB experiments created by Qiskit. """ QUBIT_TYPES = Transmon @dsl.quantum_operation def delay(self, q: Transmon, time: float) -> None: """A delay operation on the drive signal of the qubit.""" dsl.delay(q.signals["drive"], time=time) @dsl.quantum_operation def x( self, q: Transmon, amplitude_scale: float = 1.0, amplitude: float | None = None, label: str = "x", ) -> None: """A drag pulse implementing an x rotation. The pulse length and amplitude are taken from the qubit parameters. """ pulse_parameters = {"function": "drag"} x_pulse = dsl.create_pulse(pulse_parameters, name=f"{q.uid}_{label}") if amplitude is None: amplitude = amplitude_scale * q.parameters.user_defined["amplitude_pi"] dsl.play( q.signals["drive"], amplitude=amplitude, length=q.parameters.user_defined["pulse_length"], pulse=x_pulse, ) @dsl.quantum_operation def sx(self, q: Transmon) -> None: """An sx operation used in the RB decomposition. Calls the x operation with a fixed amplitude_scale of 0.5. """ self.x.omit_section(q, amplitude_scale=0.5, label="sx") @dsl.quantum_operation def rz(self, q: Transmon, angle: float) -> None: """An operation implementing a z rotation by the given angle.""" dsl.play( signal=q.signals["drive"], pulse=None, increment_oscillator_phase=angle, ) @dsl.quantum_operation def measure(self, q: Transmon, handle: str) -> None: """An operation implementing a qubit measurement. The results are stored under the name given by handle. The readout and integration parameters are taken from the qubit. """ ro_pulse_parameters = {"function": "gaussian_square", "zero_boundaries": True} ro_pulse = dsl.create_pulse(ro_pulse_parameters, name=f"{q.uid}_readout_pulse") int_pulse_parameters = {"function": "const"} kernels = [ dsl.create_pulse(int_pulse_parameters, name=f"{q.uid}_integration_kernel") ] dsl.measure( measure_signal=q.signals["measure"], measure_pulse_amplitude=q.parameters.user_defined["readout_amplitude"], measure_pulse_length=q.parameters.user_defined["readout_length"], measure_pulse=ro_pulse, handle=handle, acquire_signal=q.signals["acquire"], integration_kernel=kernels, integration_length=q.parameters.user_defined["readout_length"], reset_delay=None, ) @dsl.quantum_operation def reset(self, q: Transmon) -> None: """An operation implementing active reset on a qubit.""" handle = f"{q.uid}_qubit_state" self.measure(q, handle=handle) self.delay(q, q.parameters.user_defined["reset_delay_length"]) with dsl.match(name=f"match_{q.uid}", handle=handle): with dsl.case(name=f"case_{q.uid}_g", state=0): pass with dsl.case(name=f"case_{q.uid}_e", state=1): self.x.omit_section(q) @dsl.quantum_operation def cx(self, q_control: Transmon, q_target: Transmon) -> None: """An operation implementing a cx gate on two qubits. The controlled X gate is implemented using a cross-resonance gate. """ cx_id = f"cx_{q_control.uid}_{q_target.uid}" # define cancellation pulses for target and control cancellation_control_n = dsl.create_pulse( {"function": "gaussian_square"}, name="CR-" ) cancellation_control_p = dsl.create_pulse( {"function": "gaussian_square"}, name="CR+" ) cancellation_target_p = dsl.create_pulse( {"function": "gaussian_square"}, name="q1+" ) cancellation_target_n = dsl.create_pulse( {"function": "gaussian_square"}, name="q1-" ) # play X pulses on both target and control with dsl.section(name=f"{cx_id}_x_both") as x180_both: self.x(q_control, label="x180") self.x(q_target, label="x180") # First cross-resonance component with dsl.section( name=f"{cx_id}_canc_p", play_after=x180_both.uid ) as cancellation_p: dsl.play(signal=q_target.signals["drive"], pulse=cancellation_target_p) dsl.play(signal=q_control.signals["flux"], pulse=cancellation_control_n) # play X pulse on control x180_control = self.x(q_control, label="x180") x180_control.play_after = cancellation_p.uid # Second cross-resonance component with dsl.section( name=f"cx_{cx_id}_canc_n", play_after=x180_control.uid ): dsl.play(signal=q_target.signals["drive"], pulse=cancellation_target_n) dsl.play(signal=q_control.signals["flux"], pulse=cancellation_control_p)

In [5]:

from laboneq.dsl.quantum import QPU

qpu = QPU(qubits=[q0, q1], quantum_operations=QASMOperations())

from laboneq.dsl.quantum import QPU qpu = QPU(qubits=[q0, q1], quantum_operations=QASMOperations())

Single-Qubit Randomised Benchmarking using Qiskit¶

You'll start by creating Standard RB experiments from the Qiskit Experiment Library here. Here, we do this for one qubit for a few different RB sequence lengths.

Note that most circuits that can be generated in Qiskit and converted to OpenQASM could be adapted to be run in a similar way in LabOne Q!

Define Circuits with Qiskit¶

In [6]:

# Use Qiskit Experiment Library to Generate RB
rb1_qiskit_circuits = randomized_benchmarking.StandardRB(
    physical_qubits=[0],
    lengths=[4, 8, 16],
    num_samples=2,
).circuits()

# Use Qiskit Experiment Library to Generate RB rb1_qiskit_circuits = randomized_benchmarking.StandardRB( physical_qubits=[0], lengths=[4, 8, 16], num_samples=2, ).circuits()

When efficiently importing and executing a list of quantum circuits, there currently are strong limitations as to how the measurements are scheduled in these experiment. We strip them here from the Qiskit circuit. We will re-add them to the LabOne Q experiment separately when doing the import.

In [7]:

for circuit in rb1_qiskit_circuits:
    circuit.remove_final_measurements()

for circuit in rb1_qiskit_circuits: circuit.remove_final_measurements()

In [8]:

rb1_qiskit_circuits[2].draw()

rb1_qiskit_circuits[2].draw()

Out[8]:

   ┌────────────────┐ ░ ┌────────────────┐ ░ ┌─────────────────┐ ░ »
q: ┤ Clifford-1Q(8) ├─░─┤ Clifford-1Q(3) ├─░─┤ Clifford-1Q(11) ├─░─»
   └────────────────┘ ░ └────────────────┘ ░ └─────────────────┘ ░ »
«   ┌─────────────────┐ ░ ┌─────────────────┐ ░ ┌─────────────────┐ ░ »
«q: ┤ Clifford-1Q(10) ├─░─┤ Clifford-1Q(19) ├─░─┤ Clifford-1Q(18) ├─░─»
«   └─────────────────┘ ░ └─────────────────┘ ░ └─────────────────┘ ░ »
«   ┌─────────────────┐ ░ ┌────────────────┐ ░ ┌─────────────────┐ ░ »
«q: ┤ Clifford-1Q(21) ├─░─┤ Clifford-1Q(6) ├─░─┤ Clifford-1Q(20) ├─░─»
«   └─────────────────┘ ░ └────────────────┘ ░ └─────────────────┘ ░ »
«   ┌─────────────────┐ ░ ┌─────────────────┐ ░ ┌─────────────────┐ ░ »
«q: ┤ Clifford-1Q(23) ├─░─┤ Clifford-1Q(22) ├─░─┤ Clifford-1Q(20) ├─░─»
«   └─────────────────┘ ░ └─────────────────┘ ░ └─────────────────┘ ░ »
«   ┌────────────────┐ ░ ┌────────────────┐ ░ ┌─────────────────┐ ░ »
«q: ┤ Clifford-1Q(6) ├─░─┤ Clifford-1Q(8) ├─░─┤ Clifford-1Q(19) ├─░─»
«   └────────────────┘ ░ └────────────────┘ ░ └─────────────────┘ ░ »
«   ┌─────────────────┐ ░ ┌────────────────┐
«q: ┤ Clifford-1Q(15) ├─░─┤ Clifford-1Q(3) ├
«   └─────────────────┘ ░ └────────────────┘

You can then use the Qiskit transpile function to obtain a representation of the circuits in your favorite set of basis gates.

Below, we choose the basis ["id", "sx", "x", "rz", "cx"]. Note that all these gates (except the identity "id") must exist in your set of quantum operations!

In [9]:

# Choose basis gates
rb1_transpiled_circuits = transpile(
    rb1_qiskit_circuits, basis_gates=["id", "sx", "x", "rz", "cx"]
)

# Choose basis gates rb1_transpiled_circuits = transpile( rb1_qiskit_circuits, basis_gates=["id", "sx", "x", "rz", "cx"] )

In [10]:

rb1_program_list = []
for circuit in rb1_transpiled_circuits:
    rb1_program_list.append(qasm3.dumps(circuit))

print(rb1_program_list[2])

rb1_program_list = [] for circuit in rb1_transpiled_circuits: rb1_program_list.append(qasm3.dumps(circuit)) print(rb1_program_list[2])

OPENQASM 3.0;
include "stdgates.inc";
qubit[1] q;
sx q[0];
barrier q[0];
sx q[0];
rz(pi/2) q[0];
barrier q[0];
rz(-pi/2) q[0];
sx q[0];
barrier q[0];
rz(pi/2) q[0];
x q[0];
barrier q[0];
rz(pi/2) q[0];
sx q[0];
rz(-pi/2) q[0];
barrier q[0];
rz(pi) q[0];
barrier q[0];
sx q[0];
rz(-pi/2) q[0];
barrier q[0];
x q[0];
barrier q[0];
rz(-pi) q[0];
sx q[0];
barrier q[0];
rz(pi/2) q[0];
sx q[0];
barrier q[0];
rz(-pi/2) q[0];
barrier q[0];
rz(-pi) q[0];
sx q[0];
barrier q[0];
x q[0];
barrier q[0];
sx q[0];
barrier q[0];
rz(pi/2) q[0];
sx q[0];
rz(-pi/2) q[0];
barrier q[0];
rz(-pi) q[0];
sx q[0];
rz(-pi/2) q[0];
barrier q[0];
sx q[0];
rz(pi/2) q[0];

Execute a single QASM program¶

Now, you'll transpile a single OpenQASM program into a LabOne Q Experiment pulse sequence using the class OpenQASMTranspiler and the options class SingleProgramOptions. Check out the LabOne Q QASM transplier tutorial to learn more about this interface.

Once you've done that, you can compile your Experiment and plot the output using the LabOne Q simulator.

Note: the parameter qubit_map below may need to be updated to match the names of the qubit register from your QASM circuit!

Below, we choose the QASM program defined in the first entry of rb1_program_list.

In [11]:

# Instantiate OpenQASMTranspiler from the QPU
transpiler = openqasm3.OpenQASMTranspiler(qpu)

# Define options
options = openqasm3.SingleProgramOptions()
# We will not change any of the default options

# Create the Experiment
rb1_exp_single_program = transpiler.experiment(  # create Experiment
    program=rb1_program_list[2],
    qubit_map={"q": [q0]},
    options=options,
)

# Set the Experiment calibration from the qubit calibration
rb1_exp_single_program.set_calibration(q0.calibration())

# Compile the Experiment
rb1_compiled_exp_single_program = my_session.compile(rb1_exp_single_program)

# Run the Experiment
rb1_results_single_program = my_session.run(rb1_compiled_exp_single_program)

# Instantiate OpenQASMTranspiler from the QPU transpiler = openqasm3.OpenQASMTranspiler(qpu) # Define options options = openqasm3.SingleProgramOptions() # We will not change any of the default options # Create the Experiment rb1_exp_single_program = transpiler.experiment( # create Experiment program=rb1_program_list[2], qubit_map={"q": [q0]}, options=options, ) # Set the Experiment calibration from the qubit calibration rb1_exp_single_program.set_calibration(q0.calibration()) # Compile the Experiment rb1_compiled_exp_single_program = my_session.compile(rb1_exp_single_program) # Run the Experiment rb1_results_single_program = my_session.run(rb1_compiled_exp_single_program)

[2024.12.19 17:10:19.737] INFO    Resolved modulation type of oscillator 'q0_readout_acquire_osc' on signal '/logical_signal_groups/q0/acquire_line' to SOFTWARE

[2024.12.19 17:10:19.737] INFO    Resolved modulation type of oscillator 'q0_drive_ge_osc' on signal '/logical_signal_groups/q0/drive_line' to HARDWARE

[2024.12.19 17:10:19.738] INFO    Starting LabOne Q Compiler run...

[2024.12.19 17:10:19.745] INFO    Schedule completed. [0.003 s]

[2024.12.19 17:10:19.758] INFO    Code generation completed for all AWGs. [0.013 s]

[2024.12.19 17:10:19.759] INFO    Completed compilation step 1 of 1. [0.017 s]

[2024.12.19 17:10:19.763] INFO     ──────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:19.763] INFO      Device       AWG   SeqC LOC   CT entries   Waveforms   Samples  

[2024.12.19 17:10:19.763] INFO     ──────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:19.764] INFO      hdawg_0        0          4            1           0         0  

[2024.12.19 17:10:19.764] INFO      shfqc_0        0          3            0           0         0  

[2024.12.19 17:10:19.764] INFO      shfqc_0_sg     0         30            7           6      4416  

[2024.12.19 17:10:19.764] INFO     ──────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:19.765] INFO      TOTAL                    37            8                  4416  

[2024.12.19 17:10:19.766] INFO     ──────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:19.772] INFO    Finished LabOne Q Compiler run.

[2024.12.19 17:10:19.787] INFO    Starting near-time execution...

[2024.12.19 17:10:19.800] INFO    Finished near-time execution.

Look at the simulated output¶

In [12]:

plot_simulation(
    rb1_compiled_exp_single_program,
    length=1.6e-6,
    plot_width=12,
    plot_height=3,
    signal_names_to_show=["drive"],
)

plot_simulation( rb1_compiled_exp_single_program, length=1.6e-6, plot_width=12, plot_height=3, signal_names_to_show=["drive"], )

Draw the circuit from above¶

In [13]:

rb1_transpiled_circuits[2].draw()

rb1_transpiled_circuits[2].draw()

Out[13]:

global phase: 0
   ┌────┐ ░ ┌────┐┌─────────┐ ░ ┌──────────┐┌────┐ ░ ┌─────────┐┌───┐ ░ »
q: ┤ √X ├─░─┤ √X ├┤ Rz(π/2) ├─░─┤ Rz(-π/2) ├┤ √X ├─░─┤ Rz(π/2) ├┤ X ├─░─»
   └────┘ ░ └────┘└─────────┘ ░ └──────────┘└────┘ ░ └─────────┘└───┘ ░ »
«   ┌─────────┐┌────┐┌──────────┐ ░ ┌───────┐ ░ ┌────┐┌──────────┐ ░ ┌───┐ ░ »
«q: ┤ Rz(π/2) ├┤ √X ├┤ Rz(-π/2) ├─░─┤ Rz(π) ├─░─┤ √X ├┤ Rz(-π/2) ├─░─┤ X ├─░─»
«   └─────────┘└────┘└──────────┘ ░ └───────┘ ░ └────┘└──────────┘ ░ └───┘ ░ »
«   ┌────────┐┌────┐ ░ ┌─────────┐┌────┐ ░ ┌──────────┐ ░ ┌────────┐┌────┐ ░ »
«q: ┤ Rz(-π) ├┤ √X ├─░─┤ Rz(π/2) ├┤ √X ├─░─┤ Rz(-π/2) ├─░─┤ Rz(-π) ├┤ √X ├─░─»
«   └────────┘└────┘ ░ └─────────┘└────┘ ░ └──────────┘ ░ └────────┘└────┘ ░ »
«   ┌───┐ ░ ┌────┐ ░ ┌─────────┐┌────┐┌──────────┐ ░ ┌────────┐┌────┐»
«q: ┤ X ├─░─┤ √X ├─░─┤ Rz(π/2) ├┤ √X ├┤ Rz(-π/2) ├─░─┤ Rz(-π) ├┤ √X ├»
«   └───┘ ░ └────┘ ░ └─────────┘└────┘└──────────┘ ░ └────────┘└────┘»
«   ┌──────────┐ ░ ┌────┐┌─────────┐
«q: ┤ Rz(-π/2) ├─░─┤ √X ├┤ Rz(π/2) ├
«   └──────────┘ ░ └────┘└─────────┘

Look at the pulse sheet¶

In [14]:

show_pulse_sheet(name="1-qubit RB", compiled_experiment=rb1_compiled_exp_single_program)

show_pulse_sheet(name="1-qubit RB", compiled_experiment=rb1_compiled_exp_single_program)

[2024.12.19 17:10:20.202] INFO    Recompiling the experiment due to missing extra information in the compiled experiment. Compile with `OUTPUT_EXTRAS=True` and `MAX_EVENTS_TO_PUBLISH=1000` to bypass this step with a small impact on the compilation time.

[2024.12.19 17:10:20.209] INFO    Resolved modulation type of oscillator 'q0_readout_acquire_osc' on signal '/logical_signal_groups/q0/acquire_line' to SOFTWARE

[2024.12.19 17:10:20.210] INFO    Resolved modulation type of oscillator 'q0_drive_ge_osc' on signal '/logical_signal_groups/q0/drive_line' to HARDWARE

[2024.12.19 17:10:20.211] INFO    Starting LabOne Q Compiler run...

[2024.12.19 17:10:20.219] INFO    Schedule completed. [0.005 s]

[2024.12.19 17:10:20.231] INFO    Code generation completed for all AWGs. [0.012 s]

[2024.12.19 17:10:20.232] INFO    Completed compilation step 1 of 1. [0.019 s]

[2024.12.19 17:10:20.234] INFO    Finished LabOne Q Compiler run.

[2024.12.19 17:10:20.245] INFO    Writing html file to /builds/qccs/laboneq-applications/docs/sources/how-to-guides/sources/04_qasm/1-qubit RB_2024-12-19-17-10-20.html

Out[14]:

1-qubit RB_2024-12-19-17-10-20.html

Execute the full RB Experiment¶

Below, we will use the .batch_experiment() method to create and Experiment from our list of QASM programs rb1_program_list, containing the full single-qubit RB experiment.

The entries in rb1_program_list are individual RB sequences of a given number of gates, m. In total, there will be $m\times K$ sequences in the list, where K is the number of randomizations of each length (the num_samples parameter in the Qiskit interface above). In our choice above, we have $K=2$ and $m\in \{4, 8, 16\}$.

In the MultiProgramOptions, you can use the field batch_execution_mode to specify how all these RB sequences in the list should be executed:

• all in real-time ("rt");
• every sequence of m gates in real-time and the iteration over the sequences in near-time ("nt");
• split the entries into the number of near-time steps (called "chunks") using the pipeliner ("pipeline"). Specify the number of chunks to use in the options field pipeline_chunk_count.

Below, we use the "pipeline" option, and split our 10 sequences into 2 chunks of 3 RB sequences each. This means that we will have two near-time steps, and each real-time loop will run over 3 RB sequences (all the lengths, in our case).

Note that here we use a different options class, MultiProgramOptions.

In [15]:

# Instantiate OpenQASMTranspiler from the QPU
transpiler = openqasm3.OpenQASMTranspiler(qpu)

# Define options
options = openqasm3.MultiProgramOptions()
options.repetition_time = 20e-5
options.batch_execution_mode = "pipeline"
options.pipeline_chunk_count = 2
options.add_reset = False

# Create the Experiment
rb1_exp = transpiler.batch_experiment(
    programs=rb1_program_list,
    qubit_map={"q": [q0]},
    options=options,
)

# Set the Experiment calibration from the qubit calibration
rb1_exp.set_calibration(q0.calibration())

# Compile the Experiment
rb1_compiled_exp = my_session.compile(rb1_exp)

# Run the Experiment
rb1_results = my_session.run(rb1_compiled_exp)

# Instantiate OpenQASMTranspiler from the QPU transpiler = openqasm3.OpenQASMTranspiler(qpu) # Define options options = openqasm3.MultiProgramOptions() options.repetition_time = 20e-5 options.batch_execution_mode = "pipeline" options.pipeline_chunk_count = 2 options.add_reset = False # Create the Experiment rb1_exp = transpiler.batch_experiment( programs=rb1_program_list, qubit_map={"q": [q0]}, options=options, ) # Set the Experiment calibration from the qubit calibration rb1_exp.set_calibration(q0.calibration()) # Compile the Experiment rb1_compiled_exp = my_session.compile(rb1_exp) # Run the Experiment rb1_results = my_session.run(rb1_compiled_exp)

[2024.12.19 17:10:20.308] INFO    Resolved modulation type of oscillator 'q0_readout_acquire_osc' on signal '/logical_signal_groups/q0/acquire_line' to SOFTWARE

[2024.12.19 17:10:20.309] INFO    Resolved modulation type of oscillator 'q0_drive_ge_osc' on signal '/logical_signal_groups/q0/drive_line' to HARDWARE

[2024.12.19 17:10:20.310] INFO    Starting LabOne Q Compiler run...

[2024.12.19 17:10:20.322] INFO    Schedule completed. [0.007 s]

[2024.12.19 17:10:20.341] INFO    Code generation completed for all AWGs. [0.018 s]

[2024.12.19 17:10:20.342] INFO    Completed compilation step 1 of 2. [0.027 s]

[2024.12.19 17:10:20.349] INFO    Schedule completed. [0.006 s]

[2024.12.19 17:10:20.367] INFO    Code generation completed for all AWGs. [0.018 s]

[2024.12.19 17:10:20.368] INFO    Completed compilation step 2 of 2. [0.026 s]

[2024.12.19 17:10:20.374] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.374] INFO      Step   Device       AWG   SeqC LOC   CT entries   Waveforms   Samples  

[2024.12.19 17:10:20.375] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.376] INFO      0      hdawg_0        0          4            1           0         0  

[2024.12.19 17:10:20.376] INFO             shfqc_0        0          8            0           1      8000  

[2024.12.19 17:10:20.377] INFO             shfqc_0_sg     0         55           17           9      6816  

[2024.12.19 17:10:20.377] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.378] INFO      1      hdawg_0        0          4            1           0         0  

[2024.12.19 17:10:20.378] INFO             shfqc_0        0          8            0           1      8000  

[2024.12.19 17:10:20.379] INFO             shfqc_0_sg     0         44           12           6      4416  

[2024.12.19 17:10:20.379] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.380] INFO             TOTAL                   111           30                 19232  

[2024.12.19 17:10:20.381] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.387] INFO    Finished LabOne Q Compiler run.

[2024.12.19 17:10:20.398] INFO    Starting near-time execution...

[2024.12.19 17:10:20.436] INFO    Finished near-time execution.

In [16]:

## KNOWN ISSUE - pulse sheet viewer and output simulation are not available

## KNOWN ISSUE - pulse sheet viewer and output simulation are not available

Execute the full RB Experiment - including active qubit reset¶

Let's re-run the single-qubit RB experiment with active reset. Just set the options field .add_reset to True.

In [17]:

# Instantiate OpenQASMTranspiler from the QPU
transpiler = openqasm3.OpenQASMTranspiler(qpu)

# Define options
options = openqasm3.MultiProgramOptions()
options.repetition_time = 20e-5
options.batch_execution_mode = "pipeline"
options.pipeline_chunk_count = 2
options.add_reset = True

# Create the Experiment
rb1_exp_with_reset = transpiler.batch_experiment(
    programs=rb1_program_list,
    qubit_map={"q": [q0]},
    options=options,
)

# Set the Experiment calibration from the qubit calibration
rb1_exp_with_reset.set_calibration(q0.calibration())

# Compile the Experiment
rb1_compiled_exp_with_reset = my_session.compile(rb1_exp_with_reset)

# Run the Experiment
rb1_results_with_reset = my_session.run(rb1_compiled_exp_with_reset)

# Instantiate OpenQASMTranspiler from the QPU transpiler = openqasm3.OpenQASMTranspiler(qpu) # Define options options = openqasm3.MultiProgramOptions() options.repetition_time = 20e-5 options.batch_execution_mode = "pipeline" options.pipeline_chunk_count = 2 options.add_reset = True # Create the Experiment rb1_exp_with_reset = transpiler.batch_experiment( programs=rb1_program_list, qubit_map={"q": [q0]}, options=options, ) # Set the Experiment calibration from the qubit calibration rb1_exp_with_reset.set_calibration(q0.calibration()) # Compile the Experiment rb1_compiled_exp_with_reset = my_session.compile(rb1_exp_with_reset) # Run the Experiment rb1_results_with_reset = my_session.run(rb1_compiled_exp_with_reset)

[2024.12.19 17:10:20.503] INFO    Resolved modulation type of oscillator 'q0_readout_acquire_osc' on signal '/logical_signal_groups/q0/acquire_line' to SOFTWARE

[2024.12.19 17:10:20.506] INFO    Resolved modulation type of oscillator 'q0_drive_ge_osc' on signal '/logical_signal_groups/q0/drive_line' to HARDWARE

[2024.12.19 17:10:20.509] INFO    Starting LabOne Q Compiler run...

[2024.12.19 17:10:20.523] INFO    Due to feedback latency constraints, the timing of the following match sections with corresponding handles were changed:
[2024.12.19 17:10:20.523] INFO      - '__match_q0_0' with handle 'q0_qubit_state', delayed by 272.00 ns
[2024.12.19 17:10:20.523] INFO      - '__match_q0_0' with handle 'q0_qubit_state', delayed by 272.00 ns
[2024.12.19 17:10:20.523] INFO      - '__match_q0_0' with handle 'q0_qubit_state', delayed by 272.00 ns

[2024.12.19 17:10:20.523] INFO    Schedule completed. [0.009 s]

[2024.12.19 17:10:20.546] INFO    Code generation completed for all AWGs. [0.022 s]

[2024.12.19 17:10:20.546] INFO    Completed compilation step 1 of 2. [0.032 s]

[2024.12.19 17:10:20.555] INFO    Due to feedback latency constraints, the timing of the following match sections with corresponding handles were changed:
[2024.12.19 17:10:20.555] INFO      - '__match_q0_0' with handle 'q0_qubit_state', delayed by 272.00 ns
[2024.12.19 17:10:20.555] INFO      - '__match_q0_0' with handle 'q0_qubit_state', delayed by 272.00 ns
[2024.12.19 17:10:20.555] INFO      [4 similar messages suppressed, see log file for full set of messages.]

[2024.12.19 17:10:20.555] INFO    Schedule completed. [0.008 s]

[2024.12.19 17:10:20.576] INFO    Code generation completed for all AWGs. [0.020 s]

[2024.12.19 17:10:20.577] INFO    Completed compilation step 2 of 2. [0.030 s]

[2024.12.19 17:10:20.582] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.583] INFO      Step   Device       AWG   SeqC LOC   CT entries   Waveforms   Samples  

[2024.12.19 17:10:20.583] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.584] INFO      0      hdawg_0        0          4            1           0         0  

[2024.12.19 17:10:20.584] INFO             shfqc_0        0          9            0           1      8000  

[2024.12.19 17:10:20.585] INFO             shfqc_0_sg     0         69           19          10      7232  

[2024.12.19 17:10:20.585] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.586] INFO      1      hdawg_0        0          4            1           0         0  

[2024.12.19 17:10:20.586] INFO             shfqc_0        0          9            0           1      8000  

[2024.12.19 17:10:20.587] INFO             shfqc_0_sg     0         58           14           7      4832  

[2024.12.19 17:10:20.588] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.588] INFO             TOTAL                   140           34                 20064  

[2024.12.19 17:10:20.589] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:20.595] INFO    Finished LabOne Q Compiler run.

[2024.12.19 17:10:20.606] INFO    Starting near-time execution...

[2024.12.19 17:10:20.641] INFO    Finished near-time execution.

Two-Qubit Randomized Benchmarking using Qiskit¶

Define Circuits with Qiskit¶

In [18]:

# Use Qiskit Experiment Library to Generate RB
rb2_qiskit_circuits = randomized_benchmarking.StandardRB(
    physical_qubits=[0, 1],
    lengths=[4, 8, 16],
    num_samples=2,
).circuits()

# Use Qiskit Experiment Library to Generate RB rb2_qiskit_circuits = randomized_benchmarking.StandardRB( physical_qubits=[0, 1], lengths=[4, 8, 16], num_samples=2, ).circuits()

When efficiently importing and executing a list of quantum circuits, there currently are strong limitations as to how the measurements are scheduled in these experiment. We strip them here from the Qiskit circuit. We will re-add them to the LabOne Q experiment separately when doing the import.

In [19]:

for circuit in rb1_qiskit_circuits:
    circuit.remove_final_measurements()

for circuit in rb1_qiskit_circuits: circuit.remove_final_measurements()

In [20]:

rb2_qiskit_circuits[0].draw()

rb2_qiskit_circuits[0].draw()

Out[20]:

        ┌────────────────────┐ ░ ┌───────────────────┐ ░ ┌────────────────────┐»
   q_0: ┤0                   ├─░─┤0                  ├─░─┤0                   ├»
        │  Clifford-2Q(5015) │ ░ │  Clifford-2Q(544) │ ░ │  Clifford-2Q(8636) │»
   q_1: ┤1                   ├─░─┤1                  ├─░─┤1                   ├»
        └────────────────────┘ ░ └───────────────────┘ ░ └────────────────────┘»
meas: 2/═══════════════════════════════════════════════════════════════════════»
                                                                               »
«         ░ ┌────────────────────┐ ░ ┌────────────────────┐ ░ ┌─┐   
«   q_0: ─░─┤0                   ├─░─┤0                   ├─░─┤M├───
«         ░ │  Clifford-2Q(6479) │ ░ │  Clifford-2Q(3457) │ ░ └╥┘┌─┐
«   q_1: ─░─┤1                   ├─░─┤1                   ├─░──╫─┤M├
«         ░ └────────────────────┘ ░ └────────────────────┘ ░  ║ └╥┘
«meas: 2/══════════════════════════════════════════════════════╩══╩═
«                                                              0  1 

You can then use the Qiskit transpile function to obtain a representation of the circuits in your favorite set of basis gates.

Below, we choose the basis ["id", "sx", "x", "rz", "cx"]. Note that all these gates (except the identity "id") must exist in your set of quantum operations!

In [21]:

# Choose basis gates
rb2_transpiled_circuits = transpile(
    rb2_qiskit_circuits, basis_gates=["id", "sx", "x", "rz", "cx"]
)

# Choose basis gates rb2_transpiled_circuits = transpile( rb2_qiskit_circuits, basis_gates=["id", "sx", "x", "rz", "cx"] )

In [22]:

rb2_program_list = []
for circuit in rb2_transpiled_circuits:
    rb2_program_list.append(qasm3.dumps(circuit))


print(rb2_program_list[0])

rb2_program_list = [] for circuit in rb2_transpiled_circuits: rb2_program_list.append(qasm3.dumps(circuit)) print(rb2_program_list[0])

OPENQASM 3.0;
include "stdgates.inc";
bit[2] meas;
qubit[2] q;
rz(pi/2) q[0];
sx q[0];
rz(-pi) q[0];
rz(pi/2) q[1];
sx q[1];
rz(pi/2) q[1];
cx q[0], q[1];
cx q[1], q[0];
rz(-pi) q[0];
sx q[0];
rz(pi/2) q[0];
rz(pi) q[1];
barrier q[0], q[1];
sx q[1];
rz(pi/2) q[1];
cx q[0], q[1];
cx q[1], q[0];
sx q[0];
rz(pi/2) q[0];
sx q[1];
rz(pi/2) q[1];
barrier q[0], q[1];
rz(pi/2) q[0];
rz(pi/2) q[1];
sx q[1];
rz(-pi) q[1];
cx q[0], q[1];
cx q[1], q[0];
cx q[0], q[1];
rz(pi) q[0];
barrier q[0], q[1];
rz(pi/2) q[0];
sx q[0];
rz(pi/2) q[0];
rz(pi/2) q[1];
sx q[1];
rz(-pi) q[1];
cx q[0], q[1];
sx q[0];
rz(-pi/2) q[0];
rz(pi) q[1];
barrier q[0], q[1];
rz(-pi) q[1];
sx q[1];
rz(-pi) q[1];
cx q[0], q[1];
cx q[1], q[0];
rz(pi/2) q[0];
sx q[0];
rz(-pi) q[0];
x q[1];
barrier q[0], q[1];
meas[0] = measure q[0];
meas[1] = measure q[1];

Execute a single QASM program¶

Now, you'll transpile a two-qubit OpenQASM program into a LabOne Q Experiment pulse sequence using the class OpenQASMTranspiler and the options class SingleProgramOptions. Check out the LabOne Q QASM transplier tutorial to learn more about this interface.

Once you've done that, you can compile your Experiment and plot the output using the LabOne Q simulator.

Note: the parameter qubit_map below may need to be updated to match the names of the qubit register from your QASM circuit!

Below, we choose the QASM program defined in the first entry of rb2_program_list.

In [23]:

# Instantiate OpenQASMTranspiler from the QPU
transpiler = openqasm3.OpenQASMTranspiler(qpu)

# Define options
options = openqasm3.SingleProgramOptions()
# We will not change any of the default options

# Create the Experiment
rb2_exp_single_program = transpiler.experiment(
    program=rb2_program_list[0],
    qubit_map={"q": [q0, q1]},
    options=options,
)

# Set the Experiment calibration from the qubit calibrations
rb2_exp_single_program.set_calibration(q0.calibration())
rb2_exp_single_program.set_calibration(q1.calibration())

# Compile the Experiment
rb2_compiled_exp_single_program = my_session.compile(rb2_exp_single_program)

# Run the Experiment
rb2_results_single_program = my_session.run(rb2_compiled_exp_single_program)

# Instantiate OpenQASMTranspiler from the QPU transpiler = openqasm3.OpenQASMTranspiler(qpu) # Define options options = openqasm3.SingleProgramOptions() # We will not change any of the default options # Create the Experiment rb2_exp_single_program = transpiler.experiment( program=rb2_program_list[0], qubit_map={"q": [q0, q1]}, options=options, ) # Set the Experiment calibration from the qubit calibrations rb2_exp_single_program.set_calibration(q0.calibration()) rb2_exp_single_program.set_calibration(q1.calibration()) # Compile the Experiment rb2_compiled_exp_single_program = my_session.compile(rb2_exp_single_program) # Run the Experiment rb2_results_single_program = my_session.run(rb2_compiled_exp_single_program)

[2024.12.19 17:10:22.242] INFO    Resolved modulation type of oscillator 'q0_readout_acquire_osc' on signal '/logical_signal_groups/q0/acquire_line' to SOFTWARE

[2024.12.19 17:10:22.243] INFO    Resolved modulation type of oscillator 'q0_drive_ge_osc' on signal '/logical_signal_groups/q0/drive_line' to HARDWARE

[2024.12.19 17:10:22.244] INFO    Resolved modulation type of oscillator 'q1_readout_acquire_osc' on signal '/logical_signal_groups/q1/acquire_line' to SOFTWARE

[2024.12.19 17:10:22.245] INFO    Resolved modulation type of oscillator 'q1_drive_ge_osc' on signal '/logical_signal_groups/q1/drive_line' to HARDWARE

[2024.12.19 17:10:22.246] INFO    Starting LabOne Q Compiler run...

[2024.12.19 17:10:22.257] INFO    Schedule completed. [0.007 s]

[2024.12.19 17:10:22.465] INFO    Code generation completed for all AWGs. [0.207 s]

[2024.12.19 17:10:22.466] INFO    Completed compilation step 1 of 1. [0.216 s]

[2024.12.19 17:10:22.471] INFO     ──────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:22.472] INFO      Device       AWG   SeqC LOC   CT entries   Waveforms   Samples  

[2024.12.19 17:10:22.472] INFO     ──────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:22.473] INFO      hdawg_0        0         69            9           8      3328  

[2024.12.19 17:10:22.473] INFO      shfqc_0        0          6            0           2     16000  

[2024.12.19 17:10:22.474] INFO      shfqc_0_sg     0         88           15          12      6912  

[2024.12.19 17:10:22.476] INFO      shfqc_0_sg     1         79           15          11      6496  

[2024.12.19 17:10:22.476] INFO     ──────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:22.477] INFO      TOTAL                   242           39                 32736  

[2024.12.19 17:10:22.478] INFO     ──────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:22.487] INFO    Finished LabOne Q Compiler run.

[2024.12.19 17:10:22.499] INFO    Starting near-time execution...

[2024.12.19 17:10:22.513] INFO    Finished near-time execution.

Look at the simulated output¶

In [24]:

plot_simulation(
    rb2_compiled_exp_single_program,
    length=15e-6,
    plot_width=12,
    plot_height=3,
    signal_names_to_show=[
        "/logical_signal_groups/q0/drive_line",
        "/logical_signal_groups/q0/flux_line",
        "/logical_signal_groups/q1/drive_line",
        "/logical_signal_groups/q1/flux_line",
    ],
)

plot_simulation( rb2_compiled_exp_single_program, length=15e-6, plot_width=12, plot_height=3, signal_names_to_show=[ "/logical_signal_groups/q0/drive_line", "/logical_signal_groups/q0/flux_line", "/logical_signal_groups/q1/drive_line", "/logical_signal_groups/q1/flux_line", ], )

Draw the circuit from above¶

In [25]:

rb2_transpiled_circuits[0].draw()

rb2_transpiled_circuits[0].draw()

Out[25]:

global phase: 7π/4
        ┌─────────┐┌────┐ ┌────────┐     ┌───┐┌────────┐┌────┐┌─────────┐ ░ »
   q_0: ┤ Rz(π/2) ├┤ √X ├─┤ Rz(-π) ├──■──┤ X ├┤ Rz(-π) ├┤ √X ├┤ Rz(π/2) ├─░─»
        ├─────────┤├────┤┌┴────────┤┌─┴─┐└─┬─┘├───────┬┘└────┘└─────────┘ ░ »
   q_1: ┤ Rz(π/2) ├┤ √X ├┤ Rz(π/2) ├┤ X ├──■──┤ Rz(π) ├───────────────────░─»
        └─────────┘└────┘└─────────┘└───┘     └───────┘                   ░ »
meas: 2/════════════════════════════════════════════════════════════════════»
                                                                            »
«                              ┌───┐┌────┐┌─────────┐ ░ ┌─────────┐      »
«   q_0: ───────────────────■──┤ X ├┤ √X ├┤ Rz(π/2) ├─░─┤ Rz(π/2) ├──────»
«        ┌────┐┌─────────┐┌─┴─┐└─┬─┘├────┤├─────────┤ ░ ├─────────┤┌────┐»
«   q_1: ┤ √X ├┤ Rz(π/2) ├┤ X ├──■──┤ √X ├┤ Rz(π/2) ├─░─┤ Rz(π/2) ├┤ √X ├»
«        └────┘└─────────┘└───┘     └────┘└─────────┘ ░ └─────────┘└────┘»
«meas: 2/════════════════════════════════════════════════════════════════»
«                                                                        »
«                       ┌───┐     ┌───────┐ ░ ┌─────────┐┌────┐┌─────────┐     »
«   q_0: ────────────■──┤ X ├──■──┤ Rz(π) ├─░─┤ Rz(π/2) ├┤ √X ├┤ Rz(π/2) ├──■──»
«        ┌────────┐┌─┴─┐└─┬─┘┌─┴─┐└───────┘ ░ ├─────────┤├────┤└┬────────┤┌─┴─┐»
«   q_1: ┤ Rz(-π) ├┤ X ├──■──┤ X ├──────────░─┤ Rz(π/2) ├┤ √X ├─┤ Rz(-π) ├┤ X ├»
«        └────────┘└───┘     └───┘          ░ └─────────┘└────┘ └────────┘└───┘»
«meas: 2/══════════════════════════════════════════════════════════════════════»
«                                                                              »
«          ┌────┐ ┌──────────┐ ░                                ┌───┐»
«   q_0: ──┤ √X ├─┤ Rz(-π/2) ├─░─────────────────────────────■──┤ X ├»
«        ┌─┴────┴┐└──────────┘ ░ ┌────────┐┌────┐┌────────┐┌─┴─┐└─┬─┘»
«   q_1: ┤ Rz(π) ├─────────────░─┤ Rz(-π) ├┤ √X ├┤ Rz(-π) ├┤ X ├──■──»
«        └───────┘             ░ └────────┘└────┘└────────┘└───┘     »
«meas: 2/════════════════════════════════════════════════════════════»
«                                                                    »
«        ┌─────────┐┌────┐┌────────┐ ░ ┌─┐   
«   q_0: ┤ Rz(π/2) ├┤ √X ├┤ Rz(-π) ├─░─┤M├───
«        └──┬───┬──┘└────┘└────────┘ ░ └╥┘┌─┐
«   q_1: ───┤ X ├────────────────────░──╫─┤M├
«           └───┘                    ░  ║ └╥┘
«meas: 2/═══════════════════════════════╩══╩═
«                                       0  1 

Look at the pulse sheet¶

In [26]:

show_pulse_sheet(
    name="2-qubit RB",
    compiled_experiment=rb2_compiled_exp_single_program,
    max_events_to_publish=10e4
)

show_pulse_sheet( name="2-qubit RB", compiled_experiment=rb2_compiled_exp_single_program, max_events_to_publish=10e4 )

[2024.12.19 17:10:23.126] INFO    Recompiling the experiment due to missing extra information in the compiled experiment. Compile with `OUTPUT_EXTRAS=True` and `MAX_EVENTS_TO_PUBLISH=100000.0` to bypass this step with a small impact on the compilation time.

[2024.12.19 17:10:23.139] INFO    Resolved modulation type of oscillator 'q0_readout_acquire_osc' on signal '/logical_signal_groups/q0/acquire_line' to SOFTWARE

[2024.12.19 17:10:23.139] INFO    Resolved modulation type of oscillator 'q0_drive_ge_osc' on signal '/logical_signal_groups/q0/drive_line' to HARDWARE

[2024.12.19 17:10:23.140] INFO    Resolved modulation type of oscillator 'q1_readout_acquire_osc' on signal '/logical_signal_groups/q1/acquire_line' to SOFTWARE

[2024.12.19 17:10:23.140] INFO    Resolved modulation type of oscillator 'q1_drive_ge_osc' on signal '/logical_signal_groups/q1/drive_line' to HARDWARE

[2024.12.19 17:10:23.142] INFO    Starting LabOne Q Compiler run...

[2024.12.19 17:10:23.156] INFO    Schedule completed. [0.011 s]

[2024.12.19 17:10:23.192] INFO    Code generation completed for all AWGs. [0.035 s]

[2024.12.19 17:10:23.193] INFO    Completed compilation step 1 of 1. [0.048 s]

[2024.12.19 17:10:23.196] INFO    Finished LabOne Q Compiler run.

[2024.12.19 17:10:23.212] INFO    Writing html file to /builds/qccs/laboneq-applications/docs/sources/how-to-guides/sources/04_qasm/2-qubit RB_2024-12-19-17-10-23.html

Out[26]:

2-qubit RB_2024-12-19-17-10-23.html

Execute the full RB Experiment¶

Below, we will use the .batch_experiment() method to create and Experiment from our list of QASM programs, rb2_program_list, containing the full two-qubit RB experiment.

The entries in rb2_program_list are individual RB sequences of a given number of gates, m. In total, there will be $m\times K$ sequences in the list, where K is the number of randomizations of each length (the num_samples parameter in the Qiskit interface above). In our choice above, we have $K=2$ and $m\in \{4, 8, 16\}$.

In the MultiProgramOptions, you can use the field batch_execution_mode to specify how all these RB sequences in the list should be executed:

• all in real-time ("rt");
• every sequence of m gates in real-time and the iteration over the sequences in near-time ("nt");
• split the entries into the number of near-time steps (called "chunks") using the pipeliner ("pipeline"). Specify the number of chunks to use in the options field pipeline_chunk_count.

Below, we use the "pipeline" option, and split our 10 sequences into 2 chunks of 3 RB sequences each. This means that we will have two near-time steps, and each real-time loop will run over 3 RB sequences (all the lengths, in our case).

Note that here we use a different options class, MultiProgramOptions.

In [27]:

# Instantiate OpenQASMTranspiler from the QPU
transpiler = openqasm3.OpenQASMTranspiler(qpu)

# Define options
options = openqasm3.MultiProgramOptions()
options.repetition_time = 100e-5
options.batch_execution_mode = "pipeline"
options.pipeline_chunk_count = 2
options.add_reset = False

# Create the Experiment
rb2_exp = transpiler.batch_experiment(
    programs=rb2_program_list,
    qubit_map={"q": [q0, q1]},
    options=options,
)

# Set the Experiment calibration from the qubit calibrations
rb2_exp.set_calibration(q0.calibration())
rb2_exp.set_calibration(q1.calibration())

# Compile the Experiment
rb2_compiled_exp = my_session.compile(rb2_exp)

# Run the Experiment
rb2_results = my_session.run(rb2_compiled_exp)

# Instantiate OpenQASMTranspiler from the QPU transpiler = openqasm3.OpenQASMTranspiler(qpu) # Define options options = openqasm3.MultiProgramOptions() options.repetition_time = 100e-5 options.batch_execution_mode = "pipeline" options.pipeline_chunk_count = 2 options.add_reset = False # Create the Experiment rb2_exp = transpiler.batch_experiment( programs=rb2_program_list, qubit_map={"q": [q0, q1]}, options=options, ) # Set the Experiment calibration from the qubit calibrations rb2_exp.set_calibration(q0.calibration()) rb2_exp.set_calibration(q1.calibration()) # Compile the Experiment rb2_compiled_exp = my_session.compile(rb2_exp) # Run the Experiment rb2_results = my_session.run(rb2_compiled_exp)

[2024.12.19 17:10:23.455] INFO    Resolved modulation type of oscillator 'q0_readout_acquire_osc' on signal '/logical_signal_groups/q0/acquire_line' to SOFTWARE

[2024.12.19 17:10:23.456] INFO    Resolved modulation type of oscillator 'q0_drive_ge_osc' on signal '/logical_signal_groups/q0/drive_line' to HARDWARE

[2024.12.19 17:10:23.456] INFO    Resolved modulation type of oscillator 'q1_readout_acquire_osc' on signal '/logical_signal_groups/q1/acquire_line' to SOFTWARE

[2024.12.19 17:10:23.457] INFO    Resolved modulation type of oscillator 'q1_drive_ge_osc' on signal '/logical_signal_groups/q1/drive_line' to HARDWARE

[2024.12.19 17:10:23.627] INFO    Starting LabOne Q Compiler run...

[2024.12.19 17:10:23.689] INFO    Schedule completed. [0.041 s]

[2024.12.19 17:10:23.801] INFO    Code generation completed for all AWGs. [0.111 s]

[2024.12.19 17:10:23.802] INFO    Completed compilation step 1 of 2. [0.154 s]

[2024.12.19 17:10:23.835] INFO    Schedule completed. [0.032 s]

[2024.12.19 17:10:23.932] INFO    Code generation completed for all AWGs. [0.096 s]

[2024.12.19 17:10:23.935] INFO    Completed compilation step 2 of 2. [0.132 s]

[2024.12.19 17:10:23.941] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:23.942] INFO      Step   Device       AWG   SeqC LOC   CT entries   Waveforms   Samples  

[2024.12.19 17:10:23.942] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:23.942] INFO      0      hdawg_0        0        232            9           8      3328  

[2024.12.19 17:10:23.943] INFO             shfqc_0        0         13            0           2     16000  

[2024.12.19 17:10:23.944] INFO             shfqc_0_sg     0        315           37          21     12960  

[2024.12.19 17:10:23.944] INFO             shfqc_0_sg     1        306           36          25     16544  

[2024.12.19 17:10:23.945] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:23.945] INFO      1      hdawg_0        0        192            9           8      3328  

[2024.12.19 17:10:23.945] INFO             shfqc_0        0         13            0           2     16000  

[2024.12.19 17:10:23.946] INFO             shfqc_0_sg     0        269           28          21     12576  

[2024.12.19 17:10:23.947] INFO             shfqc_0_sg     1        255           32          22     14912  

[2024.12.19 17:10:23.947] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:23.947] INFO             TOTAL                  1582          151                 79648  

[2024.12.19 17:10:23.948] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:23.965] INFO    Finished LabOne Q Compiler run.

[2024.12.19 17:10:24.010] INFO    Starting near-time execution...

[2024.12.19 17:10:24.047] INFO    Finished near-time execution.

In [28]:

## KNOWN ISSUE - pulse sheet viewer and output simulation are not available

## KNOWN ISSUE - pulse sheet viewer and output simulation are not available

Execute the full RB Experiment - including active qubit reset¶

Let's re-run the two-qubit RB experiment with active reset. Just set the options field .add_reset to True.

In [29]:

# Instantiate OpenQASMTranspiler from the QPU
transpiler = openqasm3.OpenQASMTranspiler(qpu)

# Define options
options = openqasm3.MultiProgramOptions()
options.repetition_time = 100e-5
options.batch_execution_mode = "pipeline"
options.pipeline_chunk_count = 2
options.add_reset = True

# Create the Experiment
rb2_exp_with_reset = transpiler.batch_experiment(
    programs=rb2_program_list,
    qubit_map={"q": [q0, q1]},
    options=options,
)

# Set the Experiment calibration from the qubit calibrations
rb2_exp_with_reset.set_calibration(q0.calibration())
rb2_exp_with_reset.set_calibration(q1.calibration())

# Compile the Experiment
rb2_compiled_exp_with_reset = my_session.compile(rb2_exp_with_reset)

# Run the Experiment
rb2_results_with_reset = my_session.run(rb2_compiled_exp_with_reset)

# Instantiate OpenQASMTranspiler from the QPU transpiler = openqasm3.OpenQASMTranspiler(qpu) # Define options options = openqasm3.MultiProgramOptions() options.repetition_time = 100e-5 options.batch_execution_mode = "pipeline" options.pipeline_chunk_count = 2 options.add_reset = True # Create the Experiment rb2_exp_with_reset = transpiler.batch_experiment( programs=rb2_program_list, qubit_map={"q": [q0, q1]}, options=options, ) # Set the Experiment calibration from the qubit calibrations rb2_exp_with_reset.set_calibration(q0.calibration()) rb2_exp_with_reset.set_calibration(q1.calibration()) # Compile the Experiment rb2_compiled_exp_with_reset = my_session.compile(rb2_exp_with_reset) # Run the Experiment rb2_results_with_reset = my_session.run(rb2_compiled_exp_with_reset)

[2024.12.19 17:10:24.451] INFO    Resolved modulation type of oscillator 'q0_readout_acquire_osc' on signal '/logical_signal_groups/q0/acquire_line' to SOFTWARE

[2024.12.19 17:10:24.452] INFO    Resolved modulation type of oscillator 'q0_drive_ge_osc' on signal '/logical_signal_groups/q0/drive_line' to HARDWARE

[2024.12.19 17:10:24.453] INFO    Resolved modulation type of oscillator 'q1_readout_acquire_osc' on signal '/logical_signal_groups/q1/acquire_line' to SOFTWARE

[2024.12.19 17:10:24.453] INFO    Resolved modulation type of oscillator 'q1_drive_ge_osc' on signal '/logical_signal_groups/q1/drive_line' to HARDWARE

[2024.12.19 17:10:24.458] INFO    Starting LabOne Q Compiler run...

[2024.12.19 17:10:24.523] INFO    Due to feedback latency constraints, the timing of the following match sections with corresponding handles were changed:
[2024.12.19 17:10:24.523] INFO      - '__match_q0_1' with handle 'q0_qubit_state', delayed by 272.00 ns
[2024.12.19 17:10:24.523] INFO      - '__match_q1_0' with handle 'q1_qubit_state', delayed by 272.00 ns
[2024.12.19 17:10:24.523] INFO      [4 similar messages suppressed, see log file for full set of messages.]

[2024.12.19 17:10:24.524] INFO    Schedule completed. [0.044 s]

[2024.12.19 17:10:24.641] INFO    Code generation completed for all AWGs. [0.117 s]

[2024.12.19 17:10:24.642] INFO    Completed compilation step 1 of 2. [0.163 s]

[2024.12.19 17:10:24.677] INFO    Due to feedback latency constraints, the timing of the following match sections with corresponding handles were changed:
[2024.12.19 17:10:24.677] INFO      - '__match_q0_1' with handle 'q0_qubit_state', delayed by 272.00 ns
[2024.12.19 17:10:24.677] INFO      - '__match_q1_0' with handle 'q1_qubit_state', delayed by 272.00 ns
[2024.12.19 17:10:24.677] INFO      [10 similar messages suppressed, see log file for full set of messages.]

[2024.12.19 17:10:24.678] INFO    Schedule completed. [0.036 s]

[2024.12.19 17:10:24.940] INFO    Code generation completed for all AWGs. [0.261 s]

[2024.12.19 17:10:24.944] INFO    Completed compilation step 2 of 2. [0.301 s]

[2024.12.19 17:10:24.951] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:24.952] INFO      Step   Device       AWG   SeqC LOC   CT entries   Waveforms   Samples  

[2024.12.19 17:10:24.953] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:24.953] INFO      0      hdawg_0        0        232            9           8      3328  

[2024.12.19 17:10:24.954] INFO             shfqc_0        0         14            0           2     16000  

[2024.12.19 17:10:24.955] INFO             shfqc_0_sg     0        329           39          22     13376  

[2024.12.19 17:10:24.955] INFO             shfqc_0_sg     1        317           38          25     16544  

[2024.12.19 17:10:24.956] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:24.957] INFO      1      hdawg_0        0        192            9           8      3328  

[2024.12.19 17:10:24.957] INFO             shfqc_0        0         14            0           2     16000  

[2024.12.19 17:10:24.958] INFO             shfqc_0_sg     0        283           30          22     12992  

[2024.12.19 17:10:24.959] INFO             shfqc_0_sg     1        269           34          23     15328  

[2024.12.19 17:10:24.959] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:24.960] INFO             TOTAL                  1636          159                 80896  

[2024.12.19 17:10:24.961] INFO     ─────────────────────────────────────────────────────────────────────── 

[2024.12.19 17:10:24.981] INFO    Finished LabOne Q Compiler run.

[2024.12.19 17:10:25.028] INFO    Starting near-time execution...

[2024.12.19 17:10:25.066] INFO    Finished near-time execution.