Specially calibrated instructions

By default, the quantum gates and readout operations on IBM® quantum computers are calibrated for optimal performance across general use cases. Some workloads, however, benefit from instructions whose parameters are tuned differently. For example, MidCircuitMeasure (measure_2) is a readout operation tailored for measurements in the middle of a circuit, and slower cz gates can improve the results of some error mitigation workflows.

Specially calibrated instructions come in two forms, and you access them differently:

• Instructions with different signatures are calibrated alongside the standard instructions in the default calibration, so you add them to your circuits like any other instruction. They are usually identified by a suffix, such as measure_2.
• Alternative calibrations replace parts of the default calibration with differently tuned parameters. You select one by passing a calibration_id when you retrieve the backend.

To learn how IBM quantum computers are calibrated, see Monitor, calibrate, and benchmark.

Instructions with different signatures

These instructions are calibrated with the standard instruction set, so you don't need to do anything special to retrieve a backend that supports them. To use one, add the corresponding qiskit-ibm-runtime instruction to your circuit.

* On Heron processors, the reset is conditional on the measurement result. On Nighthawk r2 processors, the reset is unconditional.

Because these instructions are not supported on every backend, check the backend's supported instructions before you use them:

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("<backend_name>")

print(backend.supported_instructions)

To find all backends that support an instruction, use:

service = QiskitRuntimeService()
backends = service.backends(filters=lambda b: "<instruction>" in b.supported_instructions)

Use instruction_signatures to see the signatures of these specially calibrated instructions:

print(backend.configuration().instruction_signatures)

Alternative calibrations

Alternative calibrations replace parts of the default calibration with differently tuned parameters. Each alternative calibration has a calibration ID, and its availability depends on the QPU.

To use an alternative calibration, pass its calibration_id when you retrieve the backend. The backend's target, and therefore the transpiler, uses the instruction properties from that calibration, and primitive jobs that you run on the backend execute with it.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("<backend_name>", calibration_id="<calibration_id>")

print(backend.calibration_id)

Slow gate calibrations

Slow gate calibrations tune the cz gate to be slower than in the default calibration. Slower cz gates might improve performance for large-scale observable estimation workflows with error mitigation, but they also increase the total duration of your circuit, which causes some additional decoherence.

On Heron processors, slow gate calibrations are also available with two modes of two-level system (TLS) bias control:

• DC TLS bias is optimized for the best instantaneous performance. The default calibration uses DC TLS bias.
• AC TLS bias modulates the TLS bias to stabilize device errors over time, which keeps the device's noise model stable during lengthy workflows. See "Noise stabilization" in Observable Estimation in the Absence of Classical Verification for details.

Nighthawk processors do not use TLS bias, so they have a single slow gate calibration.

For example:

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
# On a Heron QPU
backend = service.backend("ibm_kingston", calibration_id="slow_gates_ac")
# backend = service.backend("ibm_kingston", calibration_id="slow_gates_dc")

# On a Nighthawk QPU
backend = service.backend("ibm_phoenix", calibration_id="slow_gates")

Check gate durations

Because slow gate calibrations increase cz gate durations, compare the durations against the default calibration to understand the effect on your circuit. Use the backend's target to find the duration, in seconds, of the cz gate on a specific pair of qubits:

default_backend = service.backend("<backend_name>")
slow_backend = service.backend(
    "<backend_name>", calibration_id="slow_gates_ac"
) # Or slow_gates_dc, or slow_gates on Nighthawk

qubits = (0, 1) # Replace with a connected qubit pair on the backend
print(default_backend.target["cz"][qubits].duration)
print(slow_backend.target["cz"][qubits].duration)

Because the target reflects the selected calibration, transpile your circuits against the backend that uses the same calibration_id you plan to run on.

Next steps