qibocal.protocols.two_qubit_interaction package¶

Subpackages¶

Submodules¶

qibocal.protocols.two_qubit_interaction.optimize module¶

virtual correction experiment for two qubit gates, tune landscape.

qibocal.protocols.two_qubit_interaction.optimize.optimize_two_qubit_gate = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=True)¶: Optimize two qubit gate protocol

qibocal.protocols.two_qubit_interaction.snz_optimize module¶

class qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningParamteters(amplitude_min: float, amplitude_max: float, amplitude_step: float, amp_ratio_min: float, amp_ratio_max: float, amp_ratio_step: float, theta_start: float, theta_end: float, theta_step: float, t_idling: float, flux_time_delay: float = 0)[source]¶

Bases: Parameters

amplitude_min: float¶: Amplitude minimum.

amplitude_max: float¶: Amplitude maximum.

amplitude_step: float¶: Amplitude step.

amp_ratio_min: float¶: Minimum amplitude ratio of the two SNZ amplitudes

amp_ratio_max: float¶: Maximum amplitude ratio of the two SNZ amplitudes

amp_ratio_step: float¶: Amplitude ratio step of the two SNZ amplitudes

theta_start: float¶: Virtual phase start angle.

theta_end: float¶: Virtual phase end angle.

theta_step: float¶: Virtual phase stop angle.

t_idling: float¶: SNZ idling time, in number of steps.

flux_time_delay: float = 0¶: Wait time after flux pulse.

hardware_average: bool = False¶: By default hardware average will be performed.

nshots: int¶: Number of executions on hardware.

relaxation_time: float¶: Wait time for the qubit to decohere back to the gnd state.

class qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningResults(leakages: dict, virtual_phases: dict, fitted_parameters: dict, angles: dict)[source]¶

Bases: Results

leakages: dict¶: Qubit leakage.

virtual_phases: dict¶: Virtual Z phase correction.

fitted_parameters: dict¶: Fit parameters.

angles: dict¶: Native SNZ angle.

property pairs¶

_to_json(path: Path, filename: str)¶: Helper function to dump to json.

_to_npz(path: Path, filename: str)¶: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)¶: Load data stored in a npz file.

static load_params(path: Path, filename: str)¶: Load parameters stored in a json file.

property params: dict¶: Convert non-arrays attributes into dict.

save(path: Path)¶: Store results to file.

class qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningData(data: dict[tuple, numpy.ndarray[tuple[int, ...], numpy.dtype[dtype([('theta', '<f8'), ('target', '<f8'), ('control', '<f8')])]]] = <factory>, amplitudes: list[float] = <factory>, rel_amplitudes: list[float] = <factory>, angles: list = <factory>)[source]¶

Bases: Data

_to_json(path: Path, filename: str)¶: Helper function to dump to json.

_to_npz(path: Path, filename: str)¶: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)¶: Load data stored in a npz file.

static load_params(path: Path, filename: str)¶: Load parameters stored in a json file.

property pairs¶: Access qubit pairs ordered alphanumerically from data structure.

property params: dict¶: Convert non-arrays attributes into dict.

property qubits¶: Access qubits from data structure.

save(path: Path)¶: Store data to file.

data: dict[tuple, ndarray[tuple[int, ...], dtype[dtype(['theta', '<f8', 'target', '<f8', 'control', '<f8'])]]]¶: Raw data.

amplitudes: list[float]¶: “Amplitudes swept.

rel_amplitudes: list[float]¶: Durations swept.

angles: list¶: Virtual phases.

filter_data_key(target, control, rel_amplitude, amplitude)[source]¶

property order_pairs¶

property swept_virtual_phases¶: List of swept phases.

register_qubit(target, control, setup, ratio, theta, amp, prob_control, prob_target)[source]¶: Store output for single pair.

qibocal.protocols.two_qubit_interaction.snz_optimize._aquisition(params: ~qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningParamteters, platform: ~qibocal.calibration.platform.CalibrationPlatform, targets: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]) → SNZFinetuningData[source]¶: Acquisition for the optimization of SNZ amplitudes. The amplitude of the SNZ pulse and its amplitude ratio (B/A) are swept while the virtual phase correction experiment is performed.

qibocal.protocols.two_qubit_interaction.snz_optimize._fit(data: SNZFinetuningData) → SNZFinetuningResults[source]¶: Repetition of correct virtual phase fit for all configurations.

qibocal.protocols.two_qubit_interaction.snz_optimize._plot(data: ~qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningData, fit: ~qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningResults, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]¶: Plot routine for SNZ optimization.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle module¶

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingParameters(amplitude_min: float, amplitude_max: float, amplitude_step: float, t_idle_min: float, t_idle_max: float, t_idle_step: float, theta_start: float, theta_end: float, theta_step: float, b_amplitude: float)[source]¶

Bases: Parameters

amplitude_min: float¶: Amplitude minimum.

amplitude_max: float¶: Amplitude maximum.

amplitude_step: float¶: Amplitude step.

t_idle_min: float¶: Amplitude minimum.

t_idle_max: float¶: Amplitude maximum.

t_idle_step: float¶: Amplitude step.

theta_start: float¶: Virtual phase start angle.

theta_end: float¶: Virtual phase end angle.

theta_step: float¶: Virtual phase stop angle.

hardware_average: bool = False¶: By default hardware average will be performed.

nshots: int¶: Number of executions on hardware.

relaxation_time: float¶: Wait time for the qubit to decohere back to the gnd state.

b_amplitude: float¶: SNZ B amplitude.

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingResults(leakages: dict, virtual_phases: dict, fitted_parameters: dict, angles: dict)[source]¶

Bases: SNZFinetuningResults

_to_json(path: Path, filename: str)¶: Helper function to dump to json.

_to_npz(path: Path, filename: str)¶: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)¶: Load data stored in a npz file.

static load_params(path: Path, filename: str)¶: Load parameters stored in a json file.

property pairs¶

property params: dict¶: Convert non-arrays attributes into dict.

save(path: Path)¶: Store results to file.

leakages: dict¶: Qubit leakage.

virtual_phases: dict¶: Virtual Z phase correction.

fitted_parameters: dict¶: Fit parameters.

angles: dict¶: Native SNZ angle.

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingData(data: dict[tuple, numpy.ndarray[tuple[int, ...], numpy.dtype[dtype([('theta', '<f8'), ('target', '<f8'), ('control', '<f8')])]]] = <factory>, amplitudes: list[float] = <factory>, rel_amplitudes: list[float] = <factory>, angles: list = <factory>, t_idles: list[float] = <factory>)[source]¶

Bases: SNZFinetuningData

_to_json(path: Path, filename: str)¶: Helper function to dump to json.

_to_npz(path: Path, filename: str)¶: Helper function to use np.savez while converting keys into strings.

filter_data_key(target, control, rel_amplitude, amplitude)¶

static load_data(path: Path, filename: str)¶: Load data stored in a npz file.

static load_params(path: Path, filename: str)¶: Load parameters stored in a json file.

property order_pairs¶

property pairs¶: Access qubit pairs ordered alphanumerically from data structure.

property params: dict¶: Convert non-arrays attributes into dict.

property qubits¶: Access qubits from data structure.

save(path: Path)¶: Store data to file.

property swept_virtual_phases¶: List of swept phases.

data: dict[tuple, npt.NDArray[OptimizeTwoQubitGateType]]¶: Raw data.

amplitudes: list[float]¶: “Amplitudes swept.

rel_amplitudes: list[float]¶: Durations swept.

angles: list¶: Virtual phases.

t_idles: list[float]¶

register_qubit(target, control, setup, t_idle, theta, amp, prob_control, prob_target)[source]¶: Store output for single pair.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle._aquisition(params: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingParameters, platform: ~qibocal.calibration.platform.CalibrationPlatform, targets: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]) → SNZIdlingData[source]¶: Acquisition for the optimization of SNZ amplitudes. The amplitude of the SNZ pulse and its idling time are swept while the virtual phase correction experiment is performed.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle._fit(data: SNZIdlingData) → SNZIdlingResults[source]¶: Repetition of correct virtual phase fit for all configurations.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle._plot(data: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingData, fit: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingResults, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]¶: Plot routine for OptimizeTwoQubitGate.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot module¶

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationParamteters(duration_min: float, duration_max: float, duration_step: float, t_idle_min: float, t_idle_max: float, t_idle_step: float, theta_start: float, theta_end: float, theta_step: float, b_amplitude: float)[source]¶

Bases: Parameters

duration_min: float¶: Duration minimum.

duration_max: float¶: Duration maximum.

duration_step: float¶: Duration step.

t_idle_min: float¶: t_idle minimum.

t_idle_max: float¶: t_idle maximum.

t_idle_step: float¶: t_idle step.

theta_start: float¶: Virtual phase start angle.

theta_end: float¶: Virtual phase end angle.

theta_step: float¶: Virtual phase stop angle.

b_amplitude: float¶: SNZ B amplitude.

hardware_average: bool = False¶: By default hardware average will be performed.

nshots: int¶: Number of executions on hardware.

relaxation_time: float¶: Wait time for the qubit to decohere back to the gnd state.

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationResults(leakages: dict, virtual_phases: dict, fitted_parameters: dict, angles: dict)[source]¶

Bases: SNZFinetuningResults

_to_json(path: Path, filename: str)¶: Helper function to dump to json.

_to_npz(path: Path, filename: str)¶: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)¶: Load data stored in a npz file.

static load_params(path: Path, filename: str)¶: Load parameters stored in a json file.

property pairs¶

property params: dict¶: Convert non-arrays attributes into dict.

save(path: Path)¶: Store results to file.

leakages: dict¶: Qubit leakage.

virtual_phases: dict¶: Virtual Z phase correction.

fitted_parameters: dict¶: Fit parameters.

angles: dict¶: Native SNZ angle.

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationData(data: dict[tuple, numpy.ndarray[tuple[int, ...], numpy.dtype[dtype([('theta', '<f8'), ('target', '<f8'), ('control', '<f8')])]]] = <factory>, amplitudes: list[float] = <factory>, rel_amplitudes: list[float] = <factory>, angles: list = <factory>, durations: list = <factory>, t_idles: list[float] = <factory>)[source]¶

Bases: SNZFinetuningData

_to_json(path: Path, filename: str)¶: Helper function to dump to json.

_to_npz(path: Path, filename: str)¶: Helper function to use np.savez while converting keys into strings.

filter_data_key(target, control, rel_amplitude, amplitude)¶

static load_data(path: Path, filename: str)¶: Load data stored in a npz file.

static load_params(path: Path, filename: str)¶: Load parameters stored in a json file.

property order_pairs¶

property pairs¶: Access qubit pairs ordered alphanumerically from data structure.

property params: dict¶: Convert non-arrays attributes into dict.

property qubits¶: Access qubits from data structure.

save(path: Path)¶: Store data to file.

property swept_virtual_phases¶: List of swept phases.

data: dict[tuple, npt.NDArray[OptimizeTwoQubitGateType]]¶: Raw data.

amplitudes: list[float]¶: “Amplitudes swept.

rel_amplitudes: list[float]¶: Durations swept.

angles: list¶: Virtual phases.

durations: list¶: “Duratoins swept.

t_idles: list[float]¶: t_idles swept.

register_qubit(target, control, setup, t_idle, theta, duration, prob_control, prob_target)[source]¶: Store output for single pair.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot._aquisition(params: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationParamteters, platform: ~qibocal.calibration.platform.CalibrationPlatform, targets: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]) → SNZDurationData[source]¶

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot._fit(data: SNZDurationData) → SNZDurationResults[source]¶: Repetition of correct virtual phase fit for all configurations.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot._plot(data: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationData, fit: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationResults, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]¶: Plot routine for OptimizeTwoQubitGate.

qibocal.protocols.two_qubit_interaction.utils module¶

qibocal.protocols.two_qubit_interaction.utils.order_pair(pair: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)], platform: ~qibolab._core.platform.platform.Platform) → tuple[Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]][source]¶: Order a pair of qubits by drive frequency.

qibocal.protocols.two_qubit_interaction.utils.sinusoid(x, gate_repetition, amplitude, offset, phase)[source]¶: Sinusoidal fit function.

qibocal.protocols.two_qubit_interaction.utils.fit_flux_amplitude(matrix, amps, times)[source]¶

Estimate amplitude for CZ gate.

Given the pattern of a chevron plot (see for example Fig. 2 here https://arxiv.org/pdf/1907.04818.pdf). This function estimates the CZ amplitude by finding the amplitude which gives the standard deviation, indicating that there are oscillation along the z axis.

Parameters:

matrix (np.ndarray) – signal matrix
amps (np.ndarray) – amplitudes swept
times (np.ndarray) – duration swept

Returns:

estimated amplitude index (int): amplitude index delta (float): omega for estimated amplitude

Return type:

amplitude (float)

qibocal.protocols.two_qubit_interaction.utils.phase_diff(phase_1, phase_2)[source]¶: Return the phase difference of two sinusoids, normalized in the range [0, 2*pi].

qibocal.protocols.two_qubit_interaction.utils.fit_sinusoid(thetas, data, gate_repetition)[source]¶: Fit sinusoid to the given data.

qibocal.protocols.two_qubit_interaction.utils.fit_virtualz(data: dict, pair: list, thetas: list, gate_repetition: int, key=None)[source]¶

qibocal.protocols.two_qubit_interaction.virtual_z_phases module¶

CZ virtual correction experiment for two qubit gates, tune landscape.

qibocal.protocols.two_qubit_interaction.virtual_z_phases.correct_virtual_z_phases = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=True)¶: Virtual phases correction protocol.

qibocal.protocols.two_qubit_interaction.virtual_z_phases.create_sequence(platform: CalibrationPlatform, setup: Literal['I', 'X'], target_qubit: Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], control_qubit: Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ordered_pair: list[Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], native: Literal['CZ', 'iSWAP'], dt: float, flux_pulse_max_duration: float = None, gate_repetition: int = 1, flux_pulse: list | None = None) → tuple[PulseSequence, Pulse, Pulse, list[Pulse]][source]¶

Create the pulse sequence for the calibration of two-qubit gate virtual phases.

This function constructs a pulse sequence for a given two-qubit native gate native (CZ or iSWAP) on the specified qubits. The sequence includes: - A preliminary RX90 pulse on the target_qubit. - An optional X pulse on the control_qubit based on the setup type. - A flux pulse implementing the two-qubit native gate. - A delay of duration dt before the final X90 pulse on the target qubit. - Measurement pulses. It is possible to specify the maximum duration for the flux pulses with the flux_pulse_max_duration parameter.

The function returns:

The full experiment pulse sequence.
The applied flux pulse.
The final VirtualZPhase pulses to be used for phase sweeping.

qibocal.protocols.two_qubit_interaction.virtual_z_phases.fit_sinusoid(thetas, data, gate_repetition)[source]¶: Fit sinusoid to the given data.

qibocal.protocols.two_qubit_interaction.virtual_z_phases.phase_diff(phase_1, phase_2)[source]¶: Return the phase difference of two sinusoids, normalized in the range [0, 2*pi].