Work in progress

This page is only partially updated from a previous version of Qibolab.

In case of doubts, contact the Qibo developers.

Instruments

One the key features of Qibolab is its support for multiple different electronics. A list of all the supported electronics follows:

Controllers (subclasses of qibolab._core.instruments.abstract.Controller):
Other Instruments (subclasses of qibolab._core.instruments.abstract.Instrument):

All instruments inherit the qibolab._core.instruments.abstract.Instrument and implement methods for connecting and disconnecting. qibolab._core.instruments.abstract.Controller is a special case of instruments that provides the qibolab._core.instruments.abstract.execute method that deploys sequences on hardware.

Some more detail on the interal functionalities of instruments is given in How to add a new instrument in Qibolab?

The following is a table of the currently supported or not supported features (dev stands for under development):

Supported features

Feature

RFSoC

Qblox

QM

Arbitrary pulse sequence

yes

yes

yes

yes

Arbitrary waveforms

yes

yes

yes

yes

Multiplexed readout

yes

yes

yes

yes

Hardware classification

no

yes

yes

yes

Fast reset

dev

dev

dev

dev

Device simulation

no

no

yes

dev

RTS frequency

yes

yes

yes

yes

RTS amplitude

yes

yes

yes

yes

RTS duration

yes

yes

yes

yes

RTS relative phase

yes

yes

yes

yes

RTS 2D any combination

yes

yes

yes

yes

Sequence unrolling

dev

dev

dev

dev

Hardware averaging

yes

yes

yes

yes

Singleshot (no averaging)

yes

yes

yes

yes

Integrated acquisition

yes

yes

yes

yes

Classified acquisition

yes

yes

yes

yes

Raw waveform acquisition

yes

yes

yes

yes

Quantum Machines

Tested with a cluster of nine OPX+ controllers, using QOP213 and QOP220.

Qibolab is communicating with the instruments using the QUA language, via the qm-qua and qualang-tools Python libraries.

Quantum Random Number Generator

In addition to the above instruments used for QPU control, Qibolab provides a driver for sampling numbers from a quantum random number generator device (QRNG) in qibolab.instruments.qrng.QRNG. This assumes that the device is connected to the host computer via a serial port.

The following script can be used to sample 1000 floats uniformly distributed in [0, 1]:

from qibolab.instruments.qrng import QRNG

qrng = QRNG(address="/dev/ttyACM0")

qrng.connect()

samples = qrng.random(1000)

qrng.disconnect()

The QRNG produces raw entropy which is converted to uniform distribution using an exctraction algorithm. Two such algorithms are implemented

  • qibolab.instruments.qrng.ShaExtrator: default, based on SHA-256 hash algorithm,

  • qibolab.instruments.qrng.ToeplitzExtractor.

It is possible to switch extractor when instantiating the qibolab.instruments.qrng.QRNG object:

from qibolab.instruments.qrng import QRNG, ToeplitzExtractor

qrng = QRNG(address="/dev/ttyACM0", extractor=ToeplitzExtractor())

Emulation of QPU platforms

Although Qibolab is mostly dedicated to providing hardware drivers for self-hosted quantum computing setups, it is also possible to simulate the outcome of a pulse sequence with an emulator. The emulator currently available is based on QuTiP, the simulation is performed by solving the master equation for a given Hamiltonian including dissipation using mesolve.

With Qibolab it is currently possible to emulate a system of split-transmon qubits capacitively coupled. The Hamiltonian solved numerically in the case of two transmon qubits is given by

\[\frac{H}{\hbar} = \sum_{i=1}^2 \Big[ a^\dagger_i a_i \omega_i (\Phi_i) + \frac{\alpha_i}{2} a_i^\dagger a_i^\dagger a_i a_i - i \Omega_i(t) (a_i - a_i^\dagger) \Big] + g (a_1^\dagger a_2 + a_1 a_2^\dagger)\]

where \(a_i (a_i^\dagger)\) are the destruction (creation) operators for the transmon \(i\), \(\omega_i\) and \(\alpha_i / 2 \pi\) are the frequency and the anharmoncity of the transmon \(i\). Each transmon is controlled with a drive term with a Rabi frequency \(\Omega_i(t)\) and it is flux-tunable, meaning that the frequency of the transmon can be changed by applying flux \(\Phi_i\)

\[\omega_i(\Phi_i) = (\omega_i^{\text{max}} - \alpha_i) \sqrt[4]{d_i^2 + (1 - d_i^2)\cos^2\left( \pi k(\Phi_i - \Phi^{\text{sweetspot}}_i) \right)} + \alpha_i\]

where \(\omega_i^{\text{max}}\) is the maximum frequency of the transmon, \(d_i\) is the junctions asymmetry and \(\Phi^{\text{sweetspot}}_i\) is the flux value at which the transmon frequency is maximum Currently neither drive or crosstalk effects are considered. The coupling strength between the two transmons \(g\) .

Note

In most of the setups the sweetspot is identified by the offset value selected on the flux line connected to the qubit. Within the emulator it is possible to configure how to convert the offset value \(V\) to the flux value using the entry voltage_to_flux, which we denote with \(k\) in the flux line configuration. The flux is computed from the offset value as

\[\Phi = k \cdot V\]

The emulator supports also tunable based architecture, where the Hamiltonian is given by

\[\frac{H}{\hbar} = \sum_{i=1,2,c} \Big[ a^\dagger_i a_i \omega_i + \frac{\alpha_i}{2} a_i^\dagger a_i^\dagger a_i a_i \Big] - \sum_{i=1,2} i \Omega_i(t) (a_i - a_i^\dagger) + g_{12} (a_1^\dagger a_2 + a_1 a_2^\dagger) + g_{1c} (a_1^\dagger a_c + a_1 a_c^\dagger) + g_{2c} (a_2^\dagger a_c + a_2 a_c^\dagger) ,\]

where the index \(c\) refers to the coupler.

The readout pulses parameters are ignored, given that the Hamiltonian doesn’t include a resonator. The only information used when the readout pulse is placed in the sequence which is necessary to determine for how long the system should be evolved. The results retrieved by the emulator correspond to the time when the readout pulse is played.

Measurements are performed by measuring the probability of each transmon state available. In the case of two levels we return the probability of finding the transmon in either \(\ket{0}\) or \(\ket{1}\). When AveragingMode.SINGLESHOT is used samples are generated from the probabilities computed previously. If AveragingMode.CYCLIC the following weighted average is returned

\[\mu = \sum_{i=0}^{N} i p_i\]

where \(p_i\) is the probability corresponding to state \(\ket{i}\), and \(N\) are the transmon levels available.

The emulator supports AcquisitionType.DISCRIMINATION. We also provide a way of retrieving information with AcquisitionType.INTEGRATION by encoding into the \(I\) component the probabilities and while the \(Q\) component is set at 0. We add a Gaussian noise both on \(I\) and \(Q\). This should be enough to get some meaningful results by computing the magnitude of the signal \(\sqrt{I^2 + Q^2}\).

Example of platforms using the emulator are available here.