Note

Run interactively in jupyter notebook.

Fine Calibrations

The amplitude of a pulse can be precisely calibrated using error amplifying gate sequences. These gate sequences apply the same gate a variable number of times. Therefore, if each gate has a small error \(\delta\theta\) in the rotation angle then a sequence of \(n\) gates will have a rotation error of \(n\cdot\delta\theta\). We will work with ibmq_lima and compare our results to those reported by the backend.

import numpy as np

from qiskit import IBMQ
from qiskit.pulse import InstructionScheduleMap
import qiskit.pulse as pulse

from qiskit_experiments.library import FineXAmplitude, FineSXAmplitude

IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend('ibmq_lima')

qubit = 0

Instruction schedule map

We will run the fine calibration experiments with our own pulse schedules. To do this we create an instruction to schedule map which we populate with the schedules we wish to work with. This instruction schedule map is then given to the transpile options of the calibration experiments so that the Qiskit transpiler can attach the pulse schedules to the gates in the experiments. We will base all our pulses on the default X pulse of Lima.

x_pulse = backend.defaults().instruction_schedule_map.get('x', (qubit,)).instructions[0][1].pulse
x_pulse

Drag(duration=160, amp=(0.12494962745493425+0j), sigma=40, beta=0.5729301274879344, name='Xp_d0')

# create the schedules we need and add them to an instruction schedule map.
sx_pulse = pulse.Drag(x_pulse.duration, 0.5*x_pulse.amp, x_pulse.sigma, x_pulse.beta, name="SXp_d0")
y_pulse = pulse.Drag(x_pulse.duration, 1.0j*x_pulse.amp, x_pulse.sigma, x_pulse.beta, name="Yp_d0")

d0, inst_map = pulse.DriveChannel(qubit), InstructionScheduleMap()

for name, pulse_ in [("x", x_pulse), ("y", y_pulse), ("sx", sx_pulse)]:
    with pulse.build(name=name) as sched:
        pulse.play(pulse_, d0)

    inst_map.add(name, (qubit,), sched)

Fine Amplitude Calibration

ideal_amp = x_pulse.amp
print(f"The reported amplitude of the X pulse is {ideal_amp:.4f}.")

The reported amplitude of the X pulse is 0.1249+0.0000j.

Detecting an over-rotated pulse

We now take the x pulse reported by the backend and add a 2% overrotation to it by scaling the amplitude and see if the experiment can detect this overrotation. We replace the default X pulse in the instruction schedule map with this overrotated pulse.

pulse_amp = ideal_amp*1.02
target_angle = np.pi

with pulse.build(backend=backend, name="x") as x_over:
    pulse.play(pulse.Drag(x_pulse.duration, pulse_amp, x_pulse.sigma, x_pulse.beta), d0)

inst_map.add("x", (qubit,), x_over)

amp_cal = FineXAmplitude(qubit, backend=backend)
amp_cal.set_transpile_options(inst_map=inst_map)

Observe here that we added a square-root of X pulse before appyling the error amplifying sequence. This is done to be able to distinguish between over-rotated and under-rotated pulses.

amp_cal.circuits()[5].draw(output="mpl")

data_over = amp_cal.run().block_for_results()

data_over.figure(0)

print(data_over.analysis_results("d_theta"))

AnalysisResult
- name: d_theta
- value: 0.0405+/-0.0005
- χ²: 13.353155002912484
- quality: bad
- device_components: ['Q0']
- verified: False

dtheta = data_over.analysis_results("d_theta").value.nominal_value
scale = target_angle / (target_angle + dtheta)
print(f"The ideal angle is {target_angle:.2f} rad. We measured a deviation of {dtheta:.3f} rad.")
print(f"Thus, scale the {pulse_amp:.4f} pulse amplitude by {scale:.3f} to obtain {pulse_amp*scale:.5f}.")
print(f"Amplitude reported by the backend {ideal_amp:.4f}.")

The ideal angle is 3.14 rad. We measured a deviation of 0.040 rad.
Thus, scale the 0.1274+0.0000j pulse amplitude by 0.987 to obtain 0.12583+0.00000j.
Amplitude reported by the backend 0.1249+0.0000j.

data_over.analysis_results("d_theta").value

0.04045058362020325+/-0.000541620229372572

type(data_over.analysis_results("d_theta").value)
data_over.analysis_results("d_theta").value.error_components().items()

dict_items([(< amp = 0.0+/-0.7479661744812719 >, 0.00010580796839217384), (< base = 0.0+/-0.9418237321009111 >, 0.0004354677743070045), (< d_theta = 0.0+/-1.2464006817566182 >, 0.00030417916468821794)])

Detecting an under-rotated pulse

pulse_amp = ideal_amp*0.98
target_angle = np.pi

with pulse.build(backend=backend, name="xp") as x_under:
    pulse.play(pulse.Drag(x_pulse.duration, pulse_amp, x_pulse.sigma, x_pulse.beta), d0)

inst_map.add("x", (qubit,), x_under)

amp_cal = FineXAmplitude(qubit, backend=backend)
amp_cal.set_transpile_options(inst_map=inst_map)

data_under = amp_cal.run().block_for_results()

data_under.figure(0)

print(data_under.analysis_results("d_theta"))

AnalysisResult
- name: d_theta
- value: -0.0821+/-0.0006
- χ²: 9.970967124462884
- quality: bad
- device_components: ['Q0']
- verified: False

dtheta = data_under.analysis_results("d_theta").value.nominal_value
scale = target_angle / (target_angle + dtheta)
print(f"The ideal angle is {target_angle:.2f} rad. We measured a deviation of {dtheta:.3f} rad.")
print(f"Thus, scale the {pulse_amp:.4f} pulse amplitude by {scale:.3f} to obtain {pulse_amp*scale:.5f}.")
print(f"Amplitude reported by the backend {ideal_amp:.4f}.")

The ideal angle is 3.14 rad. We measured a deviation of -0.082 rad.
Thus, scale the 0.1225+0.0000j pulse amplitude by 1.027 to obtain 0.12574+0.00000j.
Amplitude reported by the backend 0.1249+0.0000j.

Analyzing a \(\frac{\pi}{2}\) pulse

We now consider the \(\frac{\pi}{2}\) rotation. Note that in this case we do not need to add a \(\frac{\pi}{2}\) rotation to the circuits.

# restore the x_pulse
inst_map.add("x", (qubit,), backend.defaults().instruction_schedule_map.get('x', (qubit,)))

amp_cal = FineSXAmplitude(qubit, backend)
amp_cal.set_transpile_options(inst_map=inst_map)

amp_cal.circuits()[5].draw(output="mpl")

data_x90p = amp_cal.run().block_for_results()

data_x90p.figure(0)

print(data_x90p.analysis_results("d_theta"))

AnalysisResult
- name: d_theta
- value: 0.00428+/-0.00033
- χ²: 11.230245902959357
- quality: bad
- device_components: ['Q0']
- verified: False

sx = backend.defaults().instruction_schedule_map.get('sx', (qubit,))
sx_ideal_amp = sx.instructions[0][1].pulse.amp

target_angle = np.pi / 2
dtheta = data_x90p.analysis_results("d_theta").value.nominal_value
scale = target_angle / (target_angle + dtheta)
print(f"The ideal angle is {target_angle:.2f} rad. We measured a deviation of {dtheta:.3f} rad.")
print(f"Thus, scale the {sx_pulse.amp:.4f} pulse amplitude by {scale:.3f} to obtain {sx_pulse.amp*scale:.5f}.")
print(f"Amplitude reported by the backend {sx_ideal_amp:.4f}.")

The ideal angle is 1.57 rad. We measured a deviation of 0.004 rad.
Thus, scale the 0.0625+0.0000j pulse amplitude by 0.997 to obtain 0.06231+0.00000j.
Amplitude reported by the backend 0.0618+0.0013j.

Let’s rerun this calibration using the updated value of the amplitude of the \(\frac{\pi}{2}\) pulse.

pulse_amp = sx_pulse.amp*scale

with pulse.build(backend=backend, name="sx") as sx_new:
    pulse.play(pulse.Drag(x_pulse.duration, pulse_amp, x_pulse.sigma, x_pulse.beta), d0)

inst_map.add("sx", (qubit,), sx_new)

data_x90p = amp_cal.run().block_for_results()

data_x90p.figure(0)

print(data_x90p.analysis_results("d_theta"))

AnalysisResult
- name: d_theta
- value: 0.00663+/-0.00033
- χ²: 12.911096523942346
- quality: bad
- device_components: ['Q0']
- verified: False

dtheta = data_x90p.analysis_results("d_theta").value.nominal_value
scale = target_angle / (target_angle + dtheta)
print(f"The ideal angle is {target_angle:.2f} rad. We measured a deviation of {dtheta:.3f} rad.")
print(f"Thus, scale the {pulse_amp:.4f} pulse amplitude by {scale:.3f} to obtain {pulse_amp*scale:.5f}.")
print(f"Amplitude reported by the backend {sx_ideal_amp:.4f}.")

The ideal angle is 1.57 rad. We measured a deviation of 0.007 rad.
Thus, scale the 0.0623+0.0000j pulse amplitude by 0.996 to obtain 0.06204+0.00000j.
Amplitude reported by the backend 0.0618+0.0013j.

Fine DRAG Calibrations

from qiskit_experiments.library import FineXDrag

ideal_beta = x_pulse.beta
print(f"The reported beta of the X pulse is {ideal_beta:.4f}.")

The reported beta of the X pulse is 0.5729.

pulse_beta = ideal_beta*1.25
target_angle = np.pi

with pulse.build(backend=backend, name="x") as x_over:
    pulse.play(pulse.Drag(x_pulse.duration, x_pulse.amp, x_pulse.sigma, pulse_beta), d0)

inst_map.add("x", (qubit,), x_over)

drag_cal = FineXDrag(qubit, backend)
drag_cal.set_transpile_options(inst_map=inst_map)

drag_cal.circuits()[2].draw("mpl")

data_drag_x = drag_cal.run().block_for_results()

data_drag_x.figure(0)

print(data_drag_x.analysis_results(0))

AnalysisResult
- name: @Parameters_ErrorAmplificationAnalysis
- value: CurveFitResult:
 - fitting method: least_squares
 - number of sub-models: 1
  * F_ping_pong(x) = amp / 2 * cos((d_theta + angle_per_gate) * x - phase_offset)...
 - success: True
 - number of function evals: 6
 - degree of freedom: 18
 - chi-square: 242.2756979579215
 - reduced chi-square: 13.459760997662306
 - Akaike info crit.: 53.886881038248454
 - Bayesian info crit.: 55.878345585356435
 - init params:
  * amp = 1.0
  * d_theta = 0.03930267433141715
  * angle_per_gate = 0.0
  * phase_offset = 1.5707963267948966
  * base = 0.5678580354911272
 - fit params:
  * amp = 1.0 ± 0.0
  * d_theta = 0.016856868773894 ± 0.0006311372319886394
  * angle_per_gate = 0.0 ± 0.0
  * phase_offset = 1.5707963267948966 ± 0.0
  * base = 0.48688791053418623 ± 0.0034365498800017027
 - correlations:
  * (d_theta, base) = -0.8622992458490701
- quality: bad
- device_components: ['Q0']
- verified: False

data_drag_x.analysis_results("d_theta").value.nominal_value

0.016856868773894

dtheta = data_drag_x.analysis_results("d_theta").value.nominal_value

ddelta = -0.25 * np.sqrt(np.pi) * dtheta * x_pulse.sigma / ((target_angle**2) / 4)

print(f"Adjust β={pulse_beta:.3f} by ddelta={ddelta:.3f} to get {ddelta + pulse_beta:.3f} as new β.")
print(f"The backend reports β={x_pulse.beta:.3f}")

Adjust β=0.716 by ddelta=-0.121 to get 0.595 as new β.
The backend reports β=0.573

Half angle calibrations

Phase errors imply that it is possible for the sx and x pulse to be misaligned. This can occure, for example, due to non-linearities in the mixer skew. The half angle experiment allows us to measure such issues.

from qiskit_experiments.library import HalfAngle

hac = HalfAngle(qubit, backend)
hac.set_transpile_options(inst_map=inst_map)

hac.circuits()[5].draw("mpl")

exp_data = hac.run().block_for_results()

exp_data.figure(0)

print(exp_data.analysis_results(0))

AnalysisResult
- name: @Parameters_ErrorAmplificationAnalysis
- value: CurveFitResult:
 - fitting method: least_squares
 - number of sub-models: 1
  * F_ping_pong(x) = amp / 2 * cos((d_theta + angle_per_gate) * x - phase_offset)...
 - success: True
 - number of function evals: 6
 - degree of freedom: 13
 - chi-square: 129.66478153568548
 - reduced chi-square: 9.974213964283498
 - Akaike info crit.: 36.35353473185864
 - Bayesian info crit.: 37.76963513406306
 - init params:
  * amp = 1.0
  * d_theta = 0.0551290748741386
  * angle_per_gate = 3.141592653589793
  * phase_offset = -1.5707963267948966
  * base = 0.5037490627343164
 - fit params:
  * amp = 1.0 ± 0.0
  * d_theta = -0.040472139117284534 ± 0.0005019078548224959
  * angle_per_gate = 3.141592653589793 ± 0.0
  * phase_offset = -1.5707963267948966 ± 0.0
  * base = 0.4856279605000334 ± 0.0019244621149488855
 - correlations:
  * (d_theta, base) = 0.04624866542183945
- quality: bad
- device_components: ['Q0']
- verified: False

dhac = exp_data.analysis_results("d_hac").value.nominal_value

sx = backend.defaults().instruction_schedule_map.get('sx', (qubit,))
sx_amp = sx.instructions[0][1].pulse.amp

print(f"Adjust the phase of {np.angle(sx_pulse.amp)} of the sx pulse by {-dhac/2:.3f} rad.")
print(f"The backend reports an angle of {np.angle(sx_amp):.3f} for the sx pulse.")

Adjust the phase of 0.0 of the sx pulse by 0.020 rad.
The backend reports an angle of 0.021 for the sx pulse.

import qiskit.tools.jupyter
%qiskit_copyright

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.