README.md

Qibolab

Qibolab is the dedicated Qibo backend for the automatic deployment of quantum circuits on quantum hardware.

Some of the key features of Qibolab are:

• Deploy Qibo models on quantum hardware easily.
• Create experimental drivers for custom lab setup.
• Support multiple heterogeneous platforms.
• Use calibration procedures from Qibocal.

Documentation

The qibolab backend documentation is available at https://qibo.science/qibolab/stable/.

Minimum working example

A simple example on how to connect to a platform and use it execute a pulse sequence:

from qibolab import create_platform

# Define platform and load specific runcard
platform = create_platform("my_platform")

# Create a pulse sequence based on native gates of qubit 0
natives = platform.natives.single_qubit[0]
sequence = natives.RX() | natives.MZ()

# Connects to lab instruments using the details specified in the calibration settings.
platform.connect()

# Execute a pulse sequence
results = platform.execute([sequence], nshots=1000)

# Grab the acquired shots corresponding to
# the measurement using its pulse id.
# The ``PulseSequence`` structure is list[tuple[ChannelId, Pulse]]
# thererefore we need to index it appropriately
# to get the acquisition pulse
readout_id = sequence.acquisitions[0][1].id
print(results[readout_id])

# Disconnect from the instruments
platform.disconnect()

Arbitrary pulse sequences can also be created using the pulse API:

from qibolab import (
    Acquisition,
    Delay,
    Gaussian,
    Pulse,
    PulseSequence,
    Readout,
    Rectangular,
)

# Crete some pulses
pulse = Pulse(
    amplitude=0.3,
    duration=40,
    relative_phase=0,
    envelope=Gaussian(rel_sigma=0.2),  # Gaussian shape with std = 0.2 * duration
)
delay = Delay(duration=40)
readout = Readout(
    acquisition=Acquisition(duration=2000),
    probe=Pulse(
        amplitude=0.9,
        duration=2000,
        envelope=Rectangular(),
        relative_phase=0,
    ),
)

# Add them to a PulseSequence
sequence = PulseSequence(
    [
        (1, pulse),  # pulse plays on channel 1
        (2, delay),  # delay and readout plays on channel 2
        (2, readout),
    ]
)

Here is another example on how to execute circuits:

from qibo import gates, models, set_backend

# Create circuit and add native gates
c = models.Circuit(1)
c.add(gates.GPI2(0, phi=0.2))
c.add(gates.M(0))


# Simulate the circuit using numpy
set_backend("numpy")
result = c(nshots=1024)
print(result.probabilities())

# Execute the circuit on hardware
set_backend("qibolab", platform="my_platform")
result = c(nshots=1024)
print(result.probabilities())

Citation policy

If you use the package please refer to the documentation for citation instructions.