qibolab package

class qibolab.AcquisitionType(value)

Bases: Enum

Data acquisition from hardware.

DISCRIMINATION = 1

Demodulate, integrate the waveform and discriminate among states based on the voltages.

INTEGRATION = 2

Demodulate and integrate the waveform.

RAW = 3

Acquire the waveform as it is.

SPECTROSCOPY = 4

Zurich Integration mode for RO frequency sweeps.

class qibolab.AveragingMode(value)

Bases: Enum

Data averaging modes from hardware.

CYCLIC = 1

Better averaging for short timescale noise.

SINGLESHOT = 2

No averaging.

Type:

SINGLESHOT

SEQUENTIAL = 3

Worse averaging for noise[Avoid]

Type:

SEQUENTIAL

class qibolab.ExecutionParameters(nshots: int | None = None, relaxation_time: int | None = None, fast_reset: bool = False, acquisition_type: AcquisitionType = AcquisitionType.DISCRIMINATION, averaging_mode: AveragingMode = AveragingMode.SINGLESHOT)

Bases: object

Data structure to deal with execution parameters.

nshots: int | None = None

Number of shots to sample from the experiment.

Default is the runcard value.

relaxation_time: int | None = None

Time to wait for the qubit to relax to its ground Sample between shots in ns.

Default is the runcard value.

fast_reset: bool = False

Enable or disable fast reset.

acquisition_type: AcquisitionType = 1

Data acquisition type.

averaging_mode: AveragingMode = 2

Data averaging mode.

property results_type

Returns corresponding results class.

class qibolab.MetaBackend

Bases: object

Meta-backend class which takes care of loading the qibolab backend.

static load(platform: str)

Loads the backend.

Parameters:

platform (str) – Name of the platform to load.

Returns:

The loaded backend.

Return type:

qibo.backends.abstract.Backend

list_available() → dict

Lists all the available qibolab platforms.

class qibolab.Platform(name: str, qubits: ~typing.Dict[str | int, ~qibolab.qubits.Qubit], pairs: ~typing.Dict[~typing.Tuple[str | int, str | int], ~qibolab.qubits.QubitPair], instruments: ~typing.Dict[str, ~qibolab.instruments.abstract.Instrument], settings: ~qibolab.platform.platform.Settings = <factory>, resonator_type: str | None = None, couplers: ~typing.Dict[str | int, ~qibolab.couplers.Coupler] = <factory>, is_connected: bool = False, topology: ~networkx.classes.graph.Graph = <factory>)

Bases: object

Platform for controlling quantum devices.

name: str

Name of the platform.

qubits: Dict[str | int, Qubit]

Dictionary mapping qubit names to qibolab.qubits.Qubit objects.

pairs: Dict[Tuple[str | int, str | int], QubitPair]

Dictionary mapping tuples of qubit names to qibolab.qubits.QubitPair objects.

instruments: Dict[str, Instrument]

Dictionary mapping instrument names to qibolab.instruments.abstract.Instrument objects.

settings: Settings

Container with default execution settings.

resonator_type: str | None = None

Type of resonator (2D or 3D) in the used QPU.

Default is 3D for single-qubit chips and 2D for multi-qubit.

couplers: Dict[str | int, Coupler]

Dictionary mapping coupler names to qibolab.couplers.Coupler objects.

is_connected: bool = False

Flag for whether we are connected to the physical instruments.

topology: Graph

Graph representing the qubit connectivity in the quantum chip.

property nqubits: int

Total number of usable qubits in the QPU.

property ordered_pairs

List of qubit pairs that are connected in the QPU.

property sampling_rate

Sampling rate of control electronics in giga samples per second (GSps).

connect()

Connect to all instruments.

disconnect()

Disconnects from instruments.

execute_pulse_sequence(sequence: PulseSequence, options: ExecutionParameters, **kwargs)

Parameters:

• sequence (qibolab.pulses.PulseSequence) – Pulse sequences to execute.

• options (qibolab.platforms.platform.ExecutionParameters) – Object holding the execution options.

• **kwargs – May need them for something

Returns:

Readout results acquired by after execution.

execute_pulse_sequences(sequences: List[PulseSequence], options: ExecutionParameters, **kwargs)

Parameters:

• sequence (List[qibolab.pulses.PulseSequence]) – Pulse sequences to execute.

• options (qibolab.platforms.platform.ExecutionParameters) – Object holding the execution options.

• **kwargs – May need them for something

Returns:

Readout results acquired by after execution.

sweep(sequence: PulseSequence, options: ExecutionParameters, *sweepers: Sweeper)

Executes a pulse sequence for different values of sweeped parameters.

Useful for performing chip characterization.

Example

import numpy as np
from qibolab.dummy import create_dummy
from qibolab.sweeper import Sweeper, Parameter
from qibolab.pulses import PulseSequence
from qibolab.execution_parameters import ExecutionParameters


platform = create_dummy()
sequence = PulseSequence()
parameter = Parameter.frequency
pulse = platform.create_qubit_readout_pulse(qubit=0, start=0)
sequence.add(pulse)
parameter_range = np.random.randint(10, size=10)
sweeper = Sweeper(parameter, parameter_range, [pulse])
platform.sweep(sequence, ExecutionParameters(), sweeper)

Returns:

Readout results acquired by after execution.

get_qubit(qubit)

Return the name of the physical qubit corresponding to a logical qubit.

Temporary fix for the compiler to work for platforms where the qubits are not named as 0, 1, 2, …

get_coupler(coupler)

Return the name of the physical coupler corresponding to a logical coupler.

Temporary fix for the compiler to work for platforms where the couplers are not named as 0, 1, 2, …

create_RX90_pulse(qubit, start=0, relative_phase=0)

create_RX_pulse(qubit, start=0, relative_phase=0)

create_RX12_pulse(qubit, start=0, relative_phase=0)

create_CZ_pulse_sequence(qubits, start=0)

create_iSWAP_pulse_sequence(qubits, start=0)

create_CNOT_pulse_sequence(qubits, start=0)

create_MZ_pulse(qubit, start)

create_qubit_drive_pulse(qubit, start, duration, relative_phase=0)

create_qubit_readout_pulse(qubit, start)

create_qubit_flux_pulse(qubit, start, duration, amplitude=1)

create_coupler_pulse(coupler, start, duration=None, amplitude=None)

create_RX90_drag_pulse(qubit, start, beta, relative_phase=0)

Create native RX90 pulse with Drag shape.

create_RX_drag_pulse(qubit, start, beta, relative_phase=0)

Create native RX pulse with Drag shape.

class qibolab.QibolabBackend(platform)

Bases: NumpyBackend

apply_gate(gate, state, nqubits)

Apply a gate to state vector.

apply_gate_density_matrix(gate, state, nqubits)

Apply a gate to density matrix.

assign_measurements(measurement_map, readout)

Assigning measurement outcomes to qibo.states.MeasurementResult for each gate.

This allows properly obtaining the measured shots from the qibolab.pulses.ReadoutPulse object obtaned after pulse sequence execution.

Parameters:

• measurement_map (dict) – Map from each measurement gate to the sequence of readout pulses implementing it.

• readout (qibolab.pulses.ReadoutPulse) – Readout result object containing the readout measurement shots. This is created in execute_circuit.

execute_circuit(circuit, initial_state=None, nshots=1000)

Executes a quantum circuit.

Parameters:

• circuit (qibo.models.circuit.Circuit) – Circuit to execute.

• initial_state (qibo.models.circuit.Circuit) – Circuit to prepare the initial state. If None the default |00...0> state is used.

• nshots (int) – Number of shots to sample from the experiment.

Returns:

MeasurementOutcomes object containing the results acquired from the execution.

execute_circuits(circuits, initial_states=None, nshots=1000)

Executes multiple quantum circuits with a single communication with the control electronics.

Circuits are unrolled to a single pulse sequence.

Parameters:

• circuits (list) – List of circuits to execute.

• initial_states (qibo.models.circuit.Circuit) – Circuit to prepare the initial state. If None the default |00...0> state is used.

• nshots (int) – Number of shots to sample from the experiment.

Returns:

List of MeasurementOutcomes objects containing the results acquired from the execution of each circuit.

qibolab.create_platform(name: str) → Platform

A platform for executing quantum algorithms.

It consists of a quantum processor QPU and a set of controlling instruments.

Parameters:

• name (str) – name of the platform. Options are ‘tiiq’, ‘qili’ and ‘icarusq’.

• path (pathlib.Path) – path with platform serialization

Returns:

The plaform class.

qibolab.execute_qasm(circuit: str, platform, initial_state=None, nshots=1000)

Executes a QASM circuit.

Parameters:

• circuit (str) – the QASM circuit.

• platform (str) – the platform where to execute the circuit.

• initial_state (qibo.models.circuit.Circuit) – Circuit to prepare the initial state. If None the default |00...0> state is used.

• nshots (int) – Number of shots to sample from the experiment.

Returns:

MeasurementOutcomes object containing the results acquired from the execution.

Subpackages

• qibolab.compilers package
  • Submodules
  • qibolab.compilers.compiler module
    • Compiler
      • Compiler.rules
      • Compiler.default()
      • Compiler.register()
      • Compiler.compile()
  • qibolab.compilers.default module
    • identity_rule()
    • z_rule()
    • rz_rule()
    • gpi2_rule()
    • gpi_rule()
    • u3_rule()
    • cz_rule()
    • cnot_rule()
    • measurement_rule()
• qibolab.dummy package
  • Submodules
  • qibolab.dummy.platform module
    • remove_couplers()
    • create_dummy()
• qibolab.instruments package
  • Subpackages
    • qibolab.instruments.qblox package
      • Submodules
      • qibolab.instruments.qblox.acquisition module
      • qibolab.instruments.qblox.cluster_qcm_bb module
      • qibolab.instruments.qblox.cluster_qcm_rf module
      • qibolab.instruments.qblox.cluster_qrm_rf module
      • qibolab.instruments.qblox.controller module
      • qibolab.instruments.qblox.debug module
      • qibolab.instruments.qblox.module module
      • qibolab.instruments.qblox.port module
      • qibolab.instruments.qblox.q1asm module
      • qibolab.instruments.qblox.sequencer module
      • qibolab.instruments.qblox.sweeper module
    • qibolab.instruments.qm package
      • Submodules
      • qibolab.instruments.qm.acquisition module
      • qibolab.instruments.qm.config module
      • qibolab.instruments.qm.controller module
      • qibolab.instruments.qm.devices module
      • qibolab.instruments.qm.ports module
      • qibolab.instruments.qm.sequence module
      • qibolab.instruments.qm.sweepers module
    • qibolab.instruments.rfsoc package
      • Submodules
      • qibolab.instruments.rfsoc.convert module
      • qibolab.instruments.rfsoc.driver module
    • qibolab.instruments.zhinst package
      • Submodules
      • qibolab.instruments.zhinst.executor module
      • qibolab.instruments.zhinst.pulse module
      • qibolab.instruments.zhinst.sweep module
      • qibolab.instruments.zhinst.util module
  • Submodules
  • qibolab.instruments.abstract module
    • InstrumentSettings
      • InstrumentSettings.dump()
    • Instrument
      • Instrument.signature
      • Instrument.connect()
      • Instrument.disconnect()
      • Instrument.setup()
    • Controller
      • Controller.PortType
      • Controller.bounds
      • Controller.setup()
      • Controller.dump()
      • Controller.sampling_rate
      • Controller.ports()
      • Controller.play()
      • Controller.sweep()
    • InstrumentException
  • qibolab.instruments.bluefors module
    • TemperatureController
      • TemperatureController.connect()
      • TemperatureController.disconnect()
      • TemperatureController.setup()
      • TemperatureController.get_data()
      • TemperatureController.read_data()
  • qibolab.instruments.dummy module
    • DummyPort
      • DummyPort.name
      • DummyPort.offset
      • DummyPort.lo_frequency
      • DummyPort.lo_power
      • DummyPort.gain
      • DummyPort.attenuation
      • DummyPort.power_range
      • DummyPort.filters
    • DummyDevice
      • DummyDevice.set()
      • DummyDevice.get()
      • DummyDevice.on()
      • DummyDevice.off()
      • DummyDevice.close()
    • DummyLocalOscillator
      • DummyLocalOscillator.create()
    • DummyInstrument
      • DummyInstrument.BOUNDS
      • DummyInstrument.PortType
      • DummyInstrument.sampling_rate
      • DummyInstrument.connect()
      • DummyInstrument.disconnect()
      • DummyInstrument.setup()
      • DummyInstrument.get_values()
      • DummyInstrument.play()
      • DummyInstrument.sweep()
  • qibolab.instruments.erasynth module
    • RECONNECTION_ATTEMPTS
    • TIMEOUT
    • ERASynthEthernet
      • ERASynthEthernet.url
      • ERASynthEthernet.post()
      • ERASynthEthernet.get()
      • ERASynthEthernet.set()
      • ERASynthEthernet.on()
      • ERASynthEthernet.off()
      • ERASynthEthernet.close()
    • ERA
      • ERA.create()
  • qibolab.instruments.icarusq module
  • qibolab.instruments.icarusqfpga module
  • qibolab.instruments.oscillator module
    • RECONNECTION_ATTEMPTS
    • LocalOscillatorSettings
      • LocalOscillatorSettings.power
      • LocalOscillatorSettings.frequency
      • LocalOscillatorSettings.ref_osc_source
      • LocalOscillatorSettings.dump()
    • LocalOscillator
      • LocalOscillator.frequency
      • LocalOscillator.power
      • LocalOscillator.ref_osc_source
      • LocalOscillator.create()
      • LocalOscillator.connect()
      • LocalOscillator.disconnect()
      • LocalOscillator.sync()
      • LocalOscillator.setup()
  • qibolab.instruments.port module
    • Port
      • Port.name
      • Port.offset
      • Port.lo_frequency
      • Port.lo_power
      • Port.gain
      • Port.attenuation
      • Port.power_range
  • qibolab.instruments.rohde_schwarz module
    • SGS100A
      • SGS100A.create()
• qibolab.platform package
  • Platform
    • Platform.name
    • Platform.qubits
    • Platform.pairs
    • Platform.instruments
    • Platform.settings
    • Platform.resonator_type
    • Platform.couplers
    • Platform.is_connected
    • Platform.topology
    • Platform.nqubits
    • Platform.ordered_pairs
    • Platform.sampling_rate
    • Platform.connect()
    • Platform.disconnect()
    • Platform.execute_pulse_sequence()
    • Platform.execute_pulse_sequences()
    • Platform.sweep()
    • Platform.get_qubit()
    • Platform.get_coupler()
    • Platform.create_RX90_pulse()
    • Platform.create_RX_pulse()
    • Platform.create_RX12_pulse()
    • Platform.create_CZ_pulse_sequence()
    • Platform.create_iSWAP_pulse_sequence()
    • Platform.create_CNOT_pulse_sequence()
    • Platform.create_MZ_pulse()
    • Platform.create_qubit_drive_pulse()
    • Platform.create_qubit_readout_pulse()
    • Platform.create_qubit_flux_pulse()
    • Platform.create_coupler_pulse()
    • Platform.create_RX90_drag_pulse()
    • Platform.create_RX_drag_pulse()
  • create_platform()
  • unroll_sequences()
  • Submodules
  • qibolab.platform.load module
    • create_platform()
    • available_platforms()
  • qibolab.platform.platform module
    • unroll_sequences()
    • Settings
      • Settings.nshots
      • Settings.relaxation_time
      • Settings.fill()
    • Platform
      • Platform.name
      • Platform.qubits
      • Platform.pairs
      • Platform.instruments
      • Platform.settings
      • Platform.resonator_type
      • Platform.couplers
      • Platform.is_connected
      • Platform.topology
      • Platform.nqubits
      • Platform.ordered_pairs
      • Platform.sampling_rate
      • Platform.connect()
      • Platform.disconnect()
      • Platform.execute_pulse_sequence()
      • Platform.execute_pulse_sequences()
      • Platform.sweep()
      • Platform.get_qubit()
      • Platform.get_coupler()
      • Platform.create_RX90_pulse()
      • Platform.create_RX_pulse()
      • Platform.create_RX12_pulse()
      • Platform.create_CZ_pulse_sequence()
      • Platform.create_iSWAP_pulse_sequence()
      • Platform.create_CNOT_pulse_sequence()
      • Platform.create_MZ_pulse()
      • Platform.create_qubit_drive_pulse()
      • Platform.create_qubit_readout_pulse()
      • Platform.create_qubit_flux_pulse()
      • Platform.create_coupler_pulse()
      • Platform.create_RX90_drag_pulse()
      • Platform.create_RX_drag_pulse()

Submodules

qibolab.backends module

qibolab.backends.execute_qasm(circuit: str, platform, initial_state=None, nshots=1000)

Executes a QASM circuit.

Parameters:

• circuit (str) – the QASM circuit.

• platform (str) – the platform where to execute the circuit.

• initial_state (qibo.models.circuit.Circuit) – Circuit to prepare the initial state. If None the default |00...0> state is used.

• nshots (int) – Number of shots to sample from the experiment.

Returns:

MeasurementOutcomes object containing the results acquired from the execution.

class qibolab.backends.QibolabBackend(platform)

Bases: NumpyBackend

apply_gate(gate, state, nqubits)

Apply a gate to state vector.

apply_gate_density_matrix(gate, state, nqubits)

Apply a gate to density matrix.

assign_measurements(measurement_map, readout)

Assigning measurement outcomes to qibo.states.MeasurementResult for each gate.

This allows properly obtaining the measured shots from the qibolab.pulses.ReadoutPulse object obtaned after pulse sequence execution.

Parameters:

• measurement_map (dict) – Map from each measurement gate to the sequence of readout pulses implementing it.

• readout (qibolab.pulses.ReadoutPulse) – Readout result object containing the readout measurement shots. This is created in execute_circuit.

execute_circuit(circuit, initial_state=None, nshots=1000)

Executes a quantum circuit.

Parameters:

• circuit (qibo.models.circuit.Circuit) – Circuit to execute.

• initial_state (qibo.models.circuit.Circuit) – Circuit to prepare the initial state. If None the default |00...0> state is used.

• nshots (int) – Number of shots to sample from the experiment.

Returns:

MeasurementOutcomes object containing the results acquired from the execution.

execute_circuits(circuits, initial_states=None, nshots=1000)

Executes multiple quantum circuits with a single communication with the control electronics.

Circuits are unrolled to a single pulse sequence.

Parameters:

• circuits (list) – List of circuits to execute.

• initial_states (qibo.models.circuit.Circuit) – Circuit to prepare the initial state. If None the default |00...0> state is used.

• nshots (int) – Number of shots to sample from the experiment.

Returns:

List of MeasurementOutcomes objects containing the results acquired from the execution of each circuit.

class qibolab.backends.MetaBackend

Bases: object

Meta-backend class which takes care of loading the qibolab backend.

static load(platform: str)

Loads the backend.

Parameters:

platform (str) – Name of the platform to load.

Returns:

The loaded backend.

Return type:

qibo.backends.abstract.Backend

list_available() → dict

Lists all the available qibolab platforms.

qibolab.channels module

qibolab.channels.check_max_offset(offset, max_offset)

Checks if a given offset value exceeds the maximum supported offset.

This is to avoid sending high currents that could damage lab equipment such as amplifiers.

class qibolab.channels.Channel(name: str, port: Port | None = None, local_oscillator: LocalOscillator | None = None, max_offset: float | None = None)

Bases: object

Representation of physical wire connection (channel).

name: str

Name of the channel from the lab schematics.

port: Port | None = None

Instrument port that is connected to this channel.

local_oscillator: LocalOscillator | None = None

Instrument object controlling the local oscillator connected to this channel.

Not applicable for setups that do not use external local oscillators because the controller can send sufficiently high frequencies or contains internal local oscillators.

max_offset: float | None = None

Maximum DC voltage that we can safely send through this channel.

Sending high voltages for prolonged times may damage amplifiers or other lab equipment. If the user attempts to send a higher value an error will be raised to prevent execution in real instruments.

property offset

DC offset that is applied to this port.

property lo_frequency

property lo_power

property gain

property attenuation

property power_range

property filter

class qibolab.channels.ChannelMap(_channels: ~typing.Dict[str, ~qibolab.channels.Channel] = <factory>)

Bases: object

Collection of qibolab.designs.channel.Channel objects identified by name.

Essentially, it allows creating a mapping of names to channels just specifying the names.

add(*items)

Add multiple items to the channel map.

If :class: qibolab.channels.Channel objects are given they are dded to the channel map. If a different type is given, a :class: qibolab.channels.Channel with the corresponding name is created and added to the channel map.

qibolab.couplers module

qibolab.couplers.QubitId

Type for Coupler names.

alias of Union[str, int]

class qibolab.couplers.Coupler(name: str | int, sweetspot: float = 0, native_pulse: ~qibolab.native.CouplerNatives = <factory>, _flux: ~qibolab.channels.Channel | None = None, qubits: ~typing.Dict = <factory>)

Bases: object

Representation of a physical coupler.

Coupler objects are instantiated by :class: qibolab.platforms.platform.Platform and are passed to instruments to play pulses on them.

name: str | int

Coupler number or name.

sweetspot: float = 0

Coupler sweetspot to center it’s flux dependence if needed.

native_pulse: CouplerNatives

For now this only contains the calibrated pulse to activate the coupler.

qubits: Dict

Qubits the coupler acts on

property flux

property channels

qibolab.execution_parameters module

class qibolab.execution_parameters.AcquisitionType(value)

Bases: Enum

Data acquisition from hardware.

DISCRIMINATION = 1

Demodulate, integrate the waveform and discriminate among states based on the voltages.

INTEGRATION = 2

Demodulate and integrate the waveform.

RAW = 3

Acquire the waveform as it is.

SPECTROSCOPY = 4

Zurich Integration mode for RO frequency sweeps.

class qibolab.execution_parameters.AveragingMode(value)

Bases: Enum

Data averaging modes from hardware.

CYCLIC = 1

Better averaging for short timescale noise.

SINGLESHOT = 2

No averaging.

Type:

SINGLESHOT

SEQUENTIAL = 3

Worse averaging for noise[Avoid]

Type:

SEQUENTIAL

class qibolab.execution_parameters.ExecutionParameters(nshots: int | None = None, relaxation_time: int | None = None, fast_reset: bool = False, acquisition_type: AcquisitionType = AcquisitionType.DISCRIMINATION, averaging_mode: AveragingMode = AveragingMode.SINGLESHOT)

Bases: object

Data structure to deal with execution parameters.

nshots: int | None = None

Number of shots to sample from the experiment.

Default is the runcard value.

relaxation_time: int | None = None

Time to wait for the qubit to relax to its ground Sample between shots in ns.

Default is the runcard value.

fast_reset: bool = False

Enable or disable fast reset.

acquisition_type: AcquisitionType = 1

Data acquisition type.

averaging_mode: AveragingMode = 2

Data averaging mode.

property results_type

Returns corresponding results class.

qibolab.kernels module

class qibolab.kernels.Kernels

Bases: dict[Union[str, int], ndarray]

A dictionary subclass for handling Qubit Kernels.

This class extends the built-in dict class and maps QubitId to numpy arrays. It provides methods to load and dump the kernels from and to a file.

classmethod load(path: Path)

Class method to load kernels from a file.

The file should contain a serialized dictionary where keys are serialized QubitId and values are numpy arrays.

dump(path: Path)

Instance method to dump the kernels to a file.

The keys (QubitId) are serialized to strings and the values (numpy arrays) are kept as is.

qibolab.native module

class qibolab.native.NativePulse(name: str, duration: int, amplitude: float, shape: str, pulse_type: PulseType, qubit: qubits.Qubit, frequency: int = 0, relative_start: int = 0, if_frequency: int | None = None, start: int = 0, phase: float = 0.0)

Bases: object

Container with parameters required to generate a pulse implementing a native gate.

name: str

Name of the gate that the pulse implements.

duration: int

amplitude: float

shape: str

pulse_type: PulseType

qubit: qubits.Qubit

frequency: int = 0

relative_start: int = 0

Relative start is relevant for two-qubit gate operations which correspond to a pulse sequence.

if_frequency: int | None = None

start: int = 0

phase: float = 0.0

classmethod from_dict(name, pulse, qubit)

Parse the dictionary provided by the runcard.

Parameters:

• name (str) – Name of the native gate (dictionary key).

• pulse (dict) – Dictionary containing the parameters of the pulse implementing the gate, as loaded from the runcard.

• qubits (qibolab.platforms.abstract.Qubit) – Qubit that the pulse is acting on

property raw

pulse(start, relative_phase=0.0)

Construct the qibolab.pulses.Pulse object implementing the gate.

Parameters:

• start (int) – Start time of the pulse in the sequence.

• relative_phase (float) – Relative phase of the pulse.

Returns:

A qibolab.pulses.DrivePulse or qibolab.pulses.DrivePulse or qibolab.pulses.FluxPulse with the pulse parameters of the gate.

class qibolab.native.VirtualZPulse(phase: float, qubit: qubits.Qubit)

Bases: object

Container with parameters required to add a virtual Z phase in a pulse sequence.

phase: float

qubit: qubits.Qubit

property raw

class qibolab.native.CouplerPulse(duration: int, amplitude: float, shape: str, coupler: couplers.Coupler, relative_start: int = 0)

Bases: object

Container with parameters required to add a coupler pulse in a pulse sequence.

duration: int

amplitude: float

shape: str

coupler: couplers.Coupler

relative_start: int = 0

classmethod from_dict(pulse, coupler)

Parse the dictionary provided by the runcard.

Parameters:

• name (str) – Name of the native gate (dictionary key).

• pulse (dict) – Dictionary containing the parameters of the pulse implementing the gate, as loaded from the runcard.

• coupler (qibolab.platforms.abstract.Coupler) – Coupler that the pulse is acting on

property raw

pulse(start)

Construct the qibolab.pulses.Pulse object implementing the gate.

Parameters:

start (int) – Start time of the pulse in the sequence.

Returns:

A qibolab.pulses.FluxPulse with the pulse parameters of the gate.

class qibolab.native.NativeSequence(name: str, pulses: ~typing.List[~qibolab.native.NativePulse | ~qibolab.native.VirtualZPulse] = <factory>, coupler_pulses: ~typing.List[~qibolab.native.CouplerPulse] = <factory>)

Bases: object

List of qibolab.platforms.native.NativePulse objects implementing a gate.

Relevant for two-qubit gates, which usually require a sequence of pulses to be implemented. These pulses may act on qubits different than the qubits the gate is targeting.

name: str

pulses: List[NativePulse | VirtualZPulse]

coupler_pulses: List[CouplerPulse]

classmethod from_dict(name, sequence, qubits, couplers)

Constructs the native sequence from the dictionaries provided in the runcard.

Parameters:

• name (str) – Name of the gate the sequence is applying.

• sequence (dict) – Dictionary describing the sequence as provided in the runcard.

• qubits (list) – List of qibolab.qubits.Qubit object for all qubits in the platform. All qubits are required because the sequence may be acting on qubits that the implemented gate is not targeting.

• couplers (list) – List of qibolab.couplers.Coupler object for all couplers in the platform. All couplers are required because the sequence may be acting on couplers that the implemented gate is not targeting.

property raw

sequence(start=0)

Creates a qibolab.pulses.PulseSequence object implementing the sequence.

class qibolab.native.SingleQubitNatives(RX: NativePulse | None = None, RX12: NativePulse | None = None, MZ: NativePulse | None = None)

Bases: object

Container with the native single-qubit gates acting on a specific qubit.

RX: NativePulse | None = None

Pulse to drive the qubit from state 0 to state 1.

RX12: NativePulse | None = None

Pulse to drive to qubit from state 1 to state 2.

MZ: NativePulse | None = None

Measurement pulse.

property RX90: NativePulse

RX90 native pulse is inferred from RX by halving its amplitude.

classmethod from_dict(qubit, native_gates)

Parse native gates of the qubit from the runcard.

Parameters:

• qubit (qibolab.qubits.Qubit) – Qubit object that the native gates are acting on.

• native_gates (dict) – Dictionary with native gate pulse parameters as loaded from the runcard.

property raw

Serialize native gate pulses.

None gates are not included.

class qibolab.native.CouplerNatives(CP: NativePulse | None = None)

Bases: object

Container with the native single-qubit gates acting on a specific qubit.

CP: NativePulse | None = None

Pulse to activate the coupler.

classmethod from_dict(coupler, native_gates)

Parse coupler native gates from the runcard.

Parameters:

• coupler (qibolab.couplers.Coupler) – Coupler object that the native pulses are acting on.

• native_gates (dict) – Dictionary with native gate pulse parameters as loaded from the runcard [Reusing the dict from qubits].

property raw

Serialize native gate pulses.

None gates are not included.

class qibolab.native.TwoQubitNatives(CZ: NativeSequence | None = None, CNOT: NativeSequence | None = None, iSWAP: NativeSequence | None = None)

Bases: object

Container with the native two-qubit gates acting on a specific pair of qubits.

CZ: NativeSequence | None = None

CNOT: NativeSequence | None = None

iSWAP: NativeSequence | None = None

property symmetric

Check if the defined two-qubit gates are symmetric between target and control qubits.

classmethod from_dict(qubits, couplers, native_gates)

property raw

qibolab.pulses module

Pulse and PulseSequence classes.

qibolab.pulses.SAMPLING_RATE = 1

Default sampling rate in gigasamples per second (GSps).

Used for generating waveform envelopes if the instruments do not provide a different value.

class qibolab.pulses.PulseType(value)

Bases: Enum

An enumeration to distinguish different types of pulses.

READOUT pulses triger acquisitions. DRIVE pulses are used to control qubit states. FLUX pulses are used to shift the frequency of flux tunable qubits and with it implement two-qubit gates.

READOUT = 'ro'

DRIVE = 'qd'

FLUX = 'qf'

COUPLERFLUX = 'cf'

class qibolab.pulses.Waveform(data)

Bases: object

A class to save pulse waveforms.

A waveform is a list of samples, or discrete data points, used by the digital to analogue converters (DACs) to synthesise pulses.

data

a numpy array containing the samples.

Type:

np.ndarray

serial

a string that can be used as a lable to identify the waveform. It is not automatically generated, it must be set by the user.

Type:

str

DECIMALS = 5

plot(savefig_filename=None)

Plots the waveform.

Parameters:

savefig_filename (str) – a file path. If provided the plot is save to a file.

exception qibolab.pulses.ShapeInitError(msg=None, *args)

Bases: RuntimeError

Error raised when a pulse has not been fully defined.

default_msg = 'PulseShape attribute pulse must be initialised in order to be able to generate pulse waveforms'

class qibolab.pulses.PulseShape

Bases: ABC

Abstract class for pulse shapes.

This object is responsible for generating envelope and modulated waveforms from a set of pulse parameters and its type. Generates both i (in-phase) and q (quadrature) components.

pulse = None

the pulse associated with it.

Its parameters are used to generate pulse waveforms.

Type:

Pulse (Pulse)

abstract envelope_waveform_i(sampling_rate=1) → Waveform

abstract envelope_waveform_q(sampling_rate=1) → Waveform

envelope_waveforms(sampling_rate=1)

A tuple with the i and q envelope waveforms of the pulse.

modulated_waveform_i(sampling_rate=1) → Waveform

The waveform of the i component of the pulse, modulated with its frequency.

modulated_waveform_q(sampling_rate=1) → Waveform

The waveform of the q component of the pulse, modulated with its frequency.

modulated_waveforms(sampling_rate=1)

A tuple with the i and q waveforms of the pulse, modulated with its frequency.

static eval(value: str) → PulseShape

Deserialize string representation.

class qibolab.pulses.Rectangular

Bases: PulseShape

Rectangular pulse shape.

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

class qibolab.pulses.Exponential(tau: float, upsilon: float, g: float = 0.1)

Bases: PulseShape

Exponential pulse shape (Square pulse with an exponential decay).

Parameters:

• tau (float) – Parameter that controls the decay of the first exponential function

• upsilon (float) – Parameter that controls the decay of the second exponential function

• g (float) – Parameter that weights the second exponential function

\[A\frac{\exp\left(-\frac{x}{\text{upsilon}}\right) + g \exp\left(-\frac{x}{\text{tau}}\right)}{1 + g}\]

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

class qibolab.pulses.Gaussian(rel_sigma: float)

Bases: PulseShape

Gaussian pulse shape.

Parameters:

rel_sigma (float) – relative sigma so that the pulse standard deviation (sigma) = duration / rel_sigma

\[A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}}\]

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

class qibolab.pulses.GaussianSquare(rel_sigma: float, width: float)

Bases: PulseShape

GaussianSquare pulse shape.

Parameters:

• rel_sigma (float) – relative sigma so that the pulse standard deviation (sigma) = duration / rel_sigma

• width (float) – Percentage of the pulse that is flat

\[A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}}[Rise] + Flat + A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}}[Decay]\]

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

class qibolab.pulses.Drag(rel_sigma, beta)

Bases: PulseShape

Derivative Removal by Adiabatic Gate (DRAG) pulse shape.

Parameters:

• rel_sigma (float) – relative sigma so that the pulse standard deviation (sigma) = duration / rel_sigma

• beta (float) – relative sigma so that the pulse standard deviation (sigma) = duration / rel_sigma

\[\]

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

class qibolab.pulses.IIR(b, a, target: PulseShape)

Bases: PulseShape

IIR Filter using scipy.signal lfilter.

property pulse

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

class qibolab.pulses.SNZ(t_idling, b_amplitude=None)

Bases: PulseShape

Sudden variant Net Zero.

https://arxiv.org/abs/2008.07411 (Supplementary materials: FIG. S1.)

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

class qibolab.pulses.eCap(alpha: float)

Bases: PulseShape

ECap pulse shape.

Parameters:

alpha (float) –

\[\begin{split}e_{\cap(t,\alpha)} &=& A[1 + \tanh(\alpha t/t_\theta)][1 + \tanh(\alpha (1 - t/t_\theta))]\\ &\times& [1 + \tanh(\alpha/2)]^{-2}\end{split}\]

envelope_waveform_i(sampling_rate=1) → Waveform

envelope_waveform_q(sampling_rate=1) → Waveform

class qibolab.pulses.Custom(envelope_i, envelope_q=None)

Bases: PulseShape

Arbitrary shape.

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

class qibolab.pulses.Pulse(start: int, duration: int, amplitude: float, frequency: int, relative_phase: float, shape: PulseShape, channel: str | None = None, type: PulseType = PulseType.DRIVE, qubit: int = 0, _if: int = 0)

Bases: object

A class to represent a pulse to be sent to the QPU.

start: int

Start time of pulse in ns.

duration: int

Pulse duration in ns.

amplitude: float

Pulse digital amplitude (unitless).

Pulse amplitudes are normalised between -1 and 1.

frequency: int

Pulse Intermediate Frequency in Hz.

The value has to be in the range [10e6 to 300e6].

relative_phase: float

Relative phase of the pulse, in radians.

shape: PulseShape

Pulse shape, as a PulseShape object.

See :py: mod:qibolab.pulses for list of available shapes.

channel: str | None = None

Channel on which the pulse should be played.

When a sequence of pulses is sent to the platform for execution, each pulse is sent to the instrument responsible for playing pulses the pulse channel. The connection of instruments with channels is defined in the platform runcard.

type: PulseType = 'qd'

Pulse type, as an element of PulseType enumeration.

qubit: int = 0

Qubit or coupler addressed by the pulse.

property finish: int | None

Time when the pulse is scheduled to finish.

property global_phase

Global phase of the pulse, in radians.

This phase is calculated from the pulse start time and frequency as 2 * pi * frequency * start.

property phase: float

Total phase of the pulse, in radians.

The total phase is computed as the sum of the global and relative phases.

property serial: str

Returns a string representation of the pulse.

property id: int

envelope_waveform_i(sampling_rate=1) → Waveform

The envelope waveform of the i component of the pulse.

envelope_waveform_q(sampling_rate=1) → Waveform

The envelope waveform of the q component of the pulse.

envelope_waveforms(sampling_rate=1)

A tuple with the i and q envelope waveforms of the pulse.

modulated_waveform_i(sampling_rate=1) → Waveform

The waveform of the i component of the pulse, modulated with its frequency.

modulated_waveform_q(sampling_rate=1) → Waveform

The waveform of the q component of the pulse, modulated with its frequency.

modulated_waveforms(sampling_rate)

A tuple with the i and q waveforms of the pulse, modulated with its frequency.

copy()

Returns a new Pulse object with the same attributes.

shallow_copy()

is_equal_ignoring_start(item) → bool

Check if two pulses are equal ignoring start time.

plot(savefig_filename=None, sampling_rate=1)

Plots the pulse envelope and modulated waveforms.

Parameters:

savefig_filename (str) – a file path. If provided the plot is save to a file.

class qibolab.pulses.ReadoutPulse(start, duration, amplitude, frequency, relative_phase, shape, channel=0, qubit=0)

Bases: Pulse

Describes a readout pulse.

See :class: qibolab.pulses.Pulse for argument desciption.

property serial

Returns a string representation of the pulse.

property global_phase

Global phase of the pulse, in radians.

This phase is calculated from the pulse start time and frequency as 2 * pi * frequency * start.

copy()

Returns a new Pulse object with the same attributes.

class qibolab.pulses.DrivePulse(start, duration, amplitude, frequency, relative_phase, shape, channel=0, qubit=0)

Bases: Pulse

Describes a qubit drive pulse.

See :class: qibolab.pulses.Pulse for argument desciption.

property serial

Returns a string representation of the pulse.

class qibolab.pulses.FluxPulse(start, duration, amplitude, shape, channel=0, qubit=0)

Bases: Pulse

Describes a qubit flux pulse.

Flux pulses have frequency and relative_phase equal to 0. Their i and q components are equal. See :class: qibolab.pulses.Pulse for argument desciption.

PULSE_TYPE = 'qf'

envelope_waveform_q(sampling_rate=1) → Waveform

Flux pulses only have i component.

modulated_waveform_i(sampling_rate=1) → Waveform

The waveform of the i component of the pulse, modulated with its frequency.

modulated_waveform_q(sampling_rate=1) → Waveform

The waveform of the q component of the pulse, modulated with its frequency.

property serial

Returns a string representation of the pulse.

class qibolab.pulses.CouplerFluxPulse(start, duration, amplitude, shape, channel=0, qubit=0)

Bases: FluxPulse

Describes a coupler flux pulse.

See :class: qibolab.pulses.FluxPulse for argument desciption.

PULSE_TYPE = 'cf'

class qibolab.pulses.PulseConstructor(value)

Bases: Enum

An enumeration to map each PulseType to the proper pulse constructor.

READOUT = <class 'qibolab.pulses.ReadoutPulse'>

DRIVE = <class 'qibolab.pulses.DrivePulse'>

FLUX = <class 'qibolab.pulses.FluxPulse'>

class qibolab.pulses.PulseSequence(*pulses)

Bases: object

A collection of scheduled pulses.

A quantum circuit can be translated into a set of scheduled pulses that implement the circuit gates. This class contains many supporting fuctions to facilitate the creation and manipulation of these collections of pulses. None of the methods of PulseSequence modify any of the properties of its pulses.

pulses

a list containing the pulses, ordered by their channel and start times.

Type:

Pulses (list)

property serial

Returns a string representation of the pulse sequence.

property count

Returns the number of pulses in the sequence.

add(*items)

Adds pulses to the sequence and sorts them by channel and start time.

index(pulse)

Returns the index of a pulse in the sequence.

pop(index=-1)

Returns the pulse with the index provided and removes it from the sequence.

remove(pulse)

Removes a pulse from the sequence.

clear()

Removes all pulses from the sequence.

shallow_copy()

Returns a shallow copy of the sequence.

It returns a new PulseSequence object with references to the same Pulse objects.

copy()

Returns a deep copy of the sequence.

It returns a new PulseSequence with replicates of each of the pulses contained in the original sequence.

property ro_pulses

Returns a new PulseSequence containing only its readout pulses.

property qd_pulses

Returns a new PulseSequence containing only its qubit drive pulses.

property qf_pulses

Returns a new PulseSequence containing only its qubit flux pulses.

property cf_pulses

Returns a new PulseSequence containing only its coupler flux pulses.

get_channel_pulses(*channels)

Returns a new PulseSequence containing only the pulses on a specific set of channels.

get_qubit_pulses(*qubits)

Returns a new PulseSequence containing only the pulses on a specific set of qubits.

coupler_pulses(*couplers)

Returns a new PulseSequence containing only the pulses on a specific set of couplers.

property is_empty

Returns True if the sequence does not contain any pulses.

property finish: int

Returns the time when the last pulse of the sequence finishes.

property start: int

Returns the start time of the first pulse of the sequence.

property duration: int

Returns duration of the sequence calculated as its finish - start times.

property channels: list

Returns list containing the channels used by the pulses in the sequence.

property qubits: list

Returns list containing the qubits associated with the pulses in the sequence.

get_pulse_overlaps()

Returns a dictionary of slices of time (tuples with start and finish times) where pulses overlap.

separate_overlapping_pulses()

Separates a sequence of overlapping pulses into a list of non- overlapping sequences.

property pulses_overlap: bool

Returns True if any of the pulses in the sequence overlap.

plot(savefig_filename=None, sampling_rate=1)

Plots the sequence of pulses.

Parameters:

savefig_filename (str) – a file path. If provided the plot is save to a file.

qibolab.qubits module

qibolab.qubits.QubitId

Type for qubit names.

alias of Union[str, int]

qibolab.qubits.CHANNEL_NAMES = ('readout', 'feedback', 'drive', 'flux', 'twpa')

Names of channels that belong to a qubit.

Not all channels are required to operate a qubit.

qibolab.qubits.EXCLUDED_FIELDS = ('readout', 'feedback', 'drive', 'flux', 'twpa', 'name', 'native_gates', 'kernel', '_flux', 'qubit1', 'qubit2', 'coupler')

Qubit dataclass fields that are excluded by the characterization property.

class qibolab.qubits.Qubit(name: str | int, bare_resonator_frequency: int = 0, readout_frequency: int = 0, drive_frequency: int = 0, anharmonicity: int = 0, sweetspot: float = 0.0, asymmetry: float = 0.0, crosstalk_matrix: dict[typing.Union[str, int], float] = <factory>, Ec: float = 0.0, Ej: float = 0.0, g: float = 0.0, assignment_fidelity: float = 0.0, readout_fidelity: float = 0.0, gate_fidelity: float = 0.0, effective_temperature: float = 0.0, peak_voltage: float = 0, pi_pulse_amplitude: float = 0, resonator_depletion_time: int = 0, T1: int = 0, T2: int = 0, T2_spin_echo: int = 0, state0_voltage: int = 0, state1_voltage: int = 0, mean_gnd_states: ~typing.List[float] = <factory>, mean_exc_states: ~typing.List[float] = <factory>, threshold: float = 0.0, iq_angle: float = 0.0, kernel: ~numpy.ndarray | None = None, mixer_drive_g: float = 0.0, mixer_drive_phi: float = 0.0, mixer_readout_g: float = 0.0, mixer_readout_phi: float = 0.0, readout: ~qibolab.channels.Channel | None = None, feedback: ~qibolab.channels.Channel | None = None, twpa: ~qibolab.channels.Channel | None = None, drive: ~qibolab.channels.Channel | None = None, _flux: ~qibolab.channels.Channel | None = None, native_gates: ~qibolab.native.SingleQubitNatives = <factory>)

Bases: object

Representation of a physical qubit.

Qubit objects are instantiated by qibolab.platforms.platform.Platform but they are passed to instrument designs in order to play pulses.

Parameters:

• name (int, str) – Qubit number or name.

• readout (qibolab.platforms.utils.Channel) – Channel used to readout pulses to the qubit.

• feedback (qibolab.platforms.utils.Channel) – Channel used to get readout feedback from the qubit.

• drive (qibolab.platforms.utils.Channel) – Channel used to send drive pulses to the qubit.

• flux (qibolab.platforms.utils.Channel) – Channel used to send flux pulses to the qubit.

• qubit (Other characterization parameters for the) –

• runcard. (loaded from the) –

name: str | int

bare_resonator_frequency: int = 0

readout_frequency: int = 0

Readout dressed frequency.

drive_frequency: int = 0

anharmonicity: int = 0

sweetspot: float = 0.0

asymmetry: float = 0.0

crosstalk_matrix: dict[Union[str, int], float]

Crosstalk matrix for voltages.

Ec: float = 0.0

Readout Charge Energy.

Ej: float = 0.0

Readout Josephson Energy.

g: float = 0.0

Readout coupling.

assignment_fidelity: float = 0.0

Assignment fidelity.

readout_fidelity: float = 0.0

Readout fidelity.

gate_fidelity: float = 0.0

Gate fidelity from standard RB.

effective_temperature: float = 0.0

Effective temperature.

peak_voltage: float = 0

pi_pulse_amplitude: float = 0

resonator_depletion_time: int = 0

T1: int = 0

T2: int = 0

T2_spin_echo: int = 0

state0_voltage: int = 0

state1_voltage: int = 0

mean_gnd_states: List[float]

mean_exc_states: List[float]

threshold: float = 0.0

iq_angle: float = 0.0

kernel: ndarray | None = None

mixer_drive_g: float = 0.0

mixer_drive_phi: float = 0.0

mixer_readout_g: float = 0.0

mixer_readout_phi: float = 0.0

readout: Channel | None = None

feedback: Channel | None = None

twpa: Channel | None = None

drive: Channel | None = None

native_gates: SingleQubitNatives

property flux

property channels

property characterization

Dictionary containing characterization parameters.

property mixer_frequencies

Get local oscillator and intermediate frequencies of native gates.

Assumes RF = LO + IF.

qibolab.qubits.QubitPairId

Type for holding QubitPair``s in the ``platform.pairs dictionary.

alias of Tuple[Union[str, int], Union[str, int]]

class qibolab.qubits.QubitPair(qubit1: ~qibolab.qubits.Qubit, qubit2: ~qibolab.qubits.Qubit, gate_fidelity: float = 0.0, cz_fidelity: float = 0.0, coupler: ~qibolab.couplers.Coupler | None = None, native_gates: ~qibolab.native.TwoQubitNatives = <factory>)

Bases: object

Data structure for holding the native two-qubit gates acting on a pair of qubits.

This is needed for symmetry to the single-qubit gates which are storred in the qibolab.platforms.abstract.Qubit.

qubit1: Qubit

First qubit of the pair.

Acts as control on two-qubit gates.

qubit2: Qubit

Second qubit of the pair.

Acts as target on two-qubit gates.

gate_fidelity: float = 0.0

Gate fidelity from standard 2q RB.

cz_fidelity: float = 0.0

Gate fidelity from CZ interleaved RB.

coupler: Coupler | None = None

native_gates: TwoQubitNatives

property characterization

Dictionary containing characterization parameters.

qibolab.result module

class qibolab.result.IntegratedResults(data: ndarray)

Bases: object

Data structure to deal with the output of qibolab.platforms.abstr act.AbstractPlatform.execute_pulse_sequence() qibolab.platforms.abstract.AbstractPlatform.sweep()

Associated with AcquisitionType.INTEGRATION and AveragingMode.SINGLESHOT

property voltage_i

Signal component i in volts.

property voltage_q

Signal component q in volts.

property magnitude

Signal magnitude in volts.

property phase

Signal phase in radians.

property phase_std

Signal phase in radians.

property serialize

Serialize as a dictionary.

property average

Perform average over i and q.

class qibolab.result.AveragedIntegratedResults(data: ndarray, std: ndarray | None = None)

Bases: IntegratedResults

Data structure to deal with the output of qibolab.platforms.abstr act.AbstractPlatform.execute_pulse_sequence() qibolab.platforms.abstract.AbstractPlatform.sweep()

Associated with AcquisitionType.INTEGRATION and AveragingMode.CYCLIC or the averages of IntegratedResults

property average

Average on AveragedIntegratedResults is itself.

property phase_std

Standard deviation is None for AveragedIntegratedResults.

property phase

Phase not unwrapped because it is a single value.

class qibolab.result.RawWaveformResults(data: ndarray)

Bases: IntegratedResults

Data structure to deal with the output of qibolab.platforms.abstr act.AbstractPlatform.execute_pulse_sequence() qibolab.platforms.abstract.AbstractPlatform.sweep()

Associated with AcquisitionType.RAW and AveragingMode.SINGLESHOT may also be used to store the integration weights ?

class qibolab.result.AveragedRawWaveformResults(data: ndarray, std: ndarray | None = None)

Bases: AveragedIntegratedResults

Data structure to deal with the output of qibolab.platforms.abstr act.AbstractPlatform.execute_pulse_sequence() qibolab.platforms.abstract.AbstractPlatform.sweep()

Associated with AcquisitionType.RAW and AveragingMode.CYCLIC or the averages of RawWaveformResults

class qibolab.result.SampleResults(data: ndarray)

Bases: object

Data structure to deal with the output of qibolab.platforms.abstr act.AbstractPlatform.execute_pulse_sequence() qibolab.platforms.abstract.AbstractPlatform.sweep()

Associated with AcquisitionType.DISCRIMINATION and AveragingMode.SINGLESHOT

probability(state=0)

Returns the statistical frequency of the specified state (0 or 1).

property serialize

Serialize as a dictionary.

property average

Perform samples average.

class qibolab.result.AveragedSampleResults(statistical_frequency: ndarray, samples: ndarray = array([], dtype=float64), std: ndarray = array([], dtype=float64))

Bases: SampleResults

Data structure to deal with the output of qibolab.platforms.abstr act.AbstractPlatform.execute_pulse_sequence() qibolab.platforms.abstract.AbstractPlatform.sweep()

Associated with AcquisitionType.DISCRIMINATION and AveragingMode.CYCLIC or the averages of SampleResults

probability(state=0)

Returns the statistical frequency of the specified state (0 or 1).

qibolab.serialize module

Helper methods for loading and saving to runcards.

The format of runcards in the qiboteam/qibolab_platforms_qrc repository is assumed here. See Using runcards example for more details.

qibolab.serialize.load_runcard(path: Path) → dict

Load runcard JSON to a dictionary.

qibolab.serialize.load_settings(runcard: dict) → Settings

Load platform settings section from the runcard.

qibolab.serialize.load_qubit_name(name: str) → str | int

Convert qubit name from string to integer or string.

qibolab.serialize.load_qubits(runcard: dict, kernels: Kernels | None = None) → Tuple[Dict[str | int, Qubit], Dict[str | int, Coupler], Dict[Tuple[str | int, str | int], QubitPair]]

Load qubits and pairs from the runcard.

Uses the native gate and characterization sections of the runcard to parse the :class: qibolab.qubits.Qubit and :class: qibolab.qubits.QubitPair objects.

qibolab.serialize.register_gates(runcard: dict, qubits: Dict[str | int, Qubit], pairs: Dict[Tuple[str | int, str | int], QubitPair], couplers: Dict[str | int, Coupler] | None = None) → Tuple[Dict[str | int, Qubit], Dict[Tuple[str | int, str | int], QubitPair]]

Register single qubit native gates to Qubit objects from the runcard.

Uses the native gate and characterization sections of the runcard to parse the qibolab.qubits.Qubit and qibolab.qubits.QubitPair objects.

qibolab.serialize.load_instrument_settings(runcard: dict, instruments: Dict[str, Instrument]) → Dict[str, Instrument]

Setup instruments according to the settings given in the runcard.

qibolab.serialize.dump_qubit_name(name: str | int) → str

Convert qubit name from integer or string to string.

qibolab.serialize.dump_native_gates(qubits: Dict[str | int, Qubit], pairs: Dict[Tuple[str | int, str | int], QubitPair], couplers: Dict[str | int, Coupler] | None = None) → dict

Dump native gates section to dictionary following the runcard format, using qubit and pair objects.

qibolab.serialize.dump_characterization(qubits: Dict[str | int, Qubit], pairs: Dict[Tuple[str | int, str | int], QubitPair] | None = None, couplers: Dict[str | int, Coupler] | None = None) → dict

Dump qubit characterization section to dictionary following the runcard format, using qubit and pair objects.

qibolab.serialize.dump_instruments(instruments: Dict[str, Instrument]) → dict

Dump instrument settings to a dictionary following the runcard format.

qibolab.serialize.dump_runcard(platform: Platform, path: Path)

Serializes the platform and saves it as a json runcard file.

The file saved follows the format explained in Using runcards.

Parameters:

• platform (qibolab.platform.Platform) – The platform to be serialized.

• path (pathlib.Path) – Path that the json file will be saved.

qibolab.serialize.dump_kernels(platform: Platform, path: Path)

Creates Kernels instance from platform and dumps as npz.

Parameters:

• platform (qibolab.platform.Platform) – The platform to be serialized.

• path (pathlib.Path) – Path that the kernels file will be saved.

qibolab.serialize.dump_platform(platform: Platform, path: Path)

Platform serialization as runcard (json) and kernels (npz).

Parameters:

• platform (qibolab.platform.Platform) – The platform to be serialized.

• path (pathlib.Path) – Path where json and npz will be dumped.

qibolab.sweeper module

class qibolab.sweeper.Parameter(value)

Bases: Enum

Sweeping parameters.

frequency = 1

amplitude = 2

duration = 3

relative_phase = 4

start = 5

attenuation = 6

gain = 7

bias = 8

lo_frequency = 9

class qibolab.sweeper.SweeperType(value)

Bases: Enum

Type of the Sweeper.

ABSOLUTE = functools.partial(<function SweeperType.<lambda>>)

FACTOR = <built-in function mul>

OFFSET = <built-in function add>

class qibolab.sweeper.Sweeper(parameter: Parameter, values: ndarray[Any, dtype[_ScalarType_co]], pulses: list | None = None, qubits: list | None = None, couplers: list | None = None, type: SweeperType | None = SweeperType.ABSOLUTE)

Bases: object

Data structure for Sweeper object.

This object is passed as an argument to the method qibolab.platforms.abstract.Platform.sweep() which enables the user to sweep a specific parameter for one or more pulses. For information on how to perform sweeps see qibolab.platforms.abstract.Platform.sweep().

Example

import numpy as np
from qibolab.dummy import create_dummy
from qibolab.sweeper import Sweeper, Parameter
from qibolab.pulses import PulseSequence
from qibolab import ExecutionParameters


platform = create_dummy()
sequence = PulseSequence()
parameter = Parameter.frequency
pulse = platform.create_qubit_readout_pulse(qubit=0, start=0)
sequence.add(pulse)
parameter_range = np.random.randint(10, size=10)
sweeper = Sweeper(parameter, parameter_range, [pulse])
platform.sweep(sequence, ExecutionParameters(), sweeper)

Parameters:

• parameter (qibolab.sweeper.Parameter) – parameter to be swept, possible choices are frequency, attenuation, amplitude, current and gain.

• _values (np.ndarray) – sweep range. If the parameter of the sweep is a pulse parameter, if the sweeper type is not ABSOLUTE, the base value will be taken from the runcard pulse parameters. If the sweep parameter is Bias, the base value will be the sweetspot of the qubits.

• pulses (list) – list of qibolab.pulses.Pulse to be swept (optional).

• qubits (list) – list of qibolab.platforms.abstract.Qubit to be swept (optional).

• type (SweeperType) – can be ABSOLUTE (the sweeper range is swept directly), FACTOR (sweeper values are multiplied by base value), OFFSET (sweeper values are added to base value)

parameter: Parameter

values: ndarray[Any, dtype[_ScalarType_co]]

pulses: list | None = None

qubits: list | None = None

couplers: list | None = None

type: SweeperType | None = functools.partial(<function SweeperType.<lambda>>)

get_values(base_value)

Convert sweeper values depending on the sweeper type.

qibolab.unrolling module

Utilities for sequence unrolling.

May be reused by different instruments.

class qibolab.unrolling.Bounds(waveforms: int, readout: int, instructions: int)

Bases: object

Instument memory limitations proxies.

waveforms: int

Waveforms estimated size.

readout: int

Number of readouts.

instructions: int

Instructions estimated size.

classmethod update(sequence: PulseSequence)

qibolab.unrolling.batch(sequences: list[qibolab.pulses.PulseSequence], bounds: Bounds)

Split a list of sequences to batches.

Takes into account the various limitations throught the mechanics defined in :cls:`Bounds`, and the numerical limitations specified by the bounds argument.

qibolab.version module