Backends, Runtime Modes, Simulation, and Noise Management

Cloud authentication, QPU, session, and batch snippets are illustrative and were not executed in this refresh. Local evidence is listed in sources.md.

BackendV2

Qiskit 2.x providers expose hardware and simulators through BackendV2. Important public attributes include:

print(backend.name)
print(backend.num_qubits)
print(backend.operation_names)
print(backend.coupling_map)
print(backend.target)
print(backend.status())

The Target describes operation support, qubit operands, connectivity, and available timing/error metadata.

Do not use backend.configuration(), BackendProperties, or other BackendV1 patterns in new code.

Connect to IBM Quantum

Use a securely saved account:

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

New account configurations use channel="ibm_quantum_platform". See setup.md for secure credential setup. Never embed or print an API key.

Discover Backends

Select by requirements, not by a system name copied from a tutorial:

backends = service.backends(
    operational=True,
    simulator=False,
    min_num_qubits=20,
)

for candidate in backends:
    status = candidate.status()
    print(
        candidate.name,
        candidate.num_qubits,
        status.pending_jobs,
    )

For exploratory work:

backend = service.least_busy(
    operational=True,
    simulator=False,
    min_num_qubits=20,
)

Least busy is not necessarily best. For a production experiment, compare:

• required qubit count,
• connectivity and native two-qubit operations,
• calibration quality on candidate subgraphs,
• control-flow or fractional-gate requirements,
• plan and region,
• queue and expected execution time.

The bundled read-only inspector summarizes one selected backend:

python scripts/inspect_runtime.py --min-qubits 20
python scripts/inspect_runtime.py --backend BACKEND_NAME --json

Inspect Target Capabilities

target = backend.target

print("operations:", sorted(backend.operation_names))
print("supports if_else:", "if_else" in backend.operation_names)
print("supports reset:", "reset" in backend.operation_names)
print("coupling edges:", list(backend.coupling_map.get_edges()))

Operation support can vary by qubit tuple. A name appearing in operation_names does not imply every qubit or pair supports it.

Prepare ISA Circuits

from qiskit.transpiler import generate_preset_pass_manager

pass_manager = generate_preset_pass_manager(
    backend=backend,
    optimization_level=1,
    seed_transpiler=23,
)
isa_circuit = pass_manager.run(circuit)

For Estimator:

isa_observable = observable.apply_layout(isa_circuit.layout)

Runtime V2 primitives do not perform this conversion automatically.

Job Mode

Use job mode for independent one-off primitive calls:

from qiskit_ibm_runtime.executor_sampler import Sampler

sampler = Sampler(mode=backend)
job = sampler.run([isa_circuit], shots=1024)

job_id = job.job_id()
print("job_id:", job_id)
result = job.result()

Persist the ID before blocking. Retrieve later:

service = QiskitRuntimeService()
job = service.job(job_id)
print(job.status())
result = job.result()

Cancel only if the experiment should no longer consume allocation:

job.cancel()

Batch Mode

Batch mode is for independent jobs that can be submitted together. It is available to Open Plan users.

from qiskit_ibm_runtime import Batch
from qiskit_ibm_runtime.executor_sampler import Sampler

with Batch(backend=backend, max_time="10m") as batch:
    sampler = Sampler(mode=batch)
    jobs = [
        sampler.run([isa_circuit], shots=1024)
        for isa_circuit in isa_circuits
    ]

# The batch accepts no new jobs; submitted jobs can still finish.
results = [job.result() for job in jobs]

Batch jobs are scheduled as a group, but do not assume an application-level result order beyond the job list you preserve.

Session Mode

Session mode is for iterative workloads such as VQE parameter updates:

from qiskit_ibm_runtime import Session
from qiskit_ibm_runtime.executor_estimator import Estimator

with Session(backend=backend, max_time="20m") as session:
    estimator = Estimator(mode=session)
    jobs = [
        estimator.run([pub], precision=0.03)
        for pub in iterative_pubs
    ]

Open Plan users cannot submit session jobs; use job or batch mode. Sessions have maximum and interactive time-to-live limits. Close them as soon as submission is complete.

Creating Estimator(mode=backend) inside a session context still selects job mode. Use mode=session.

Ideal Local Primitives

For small ideal circuits:

from qiskit.primitives import StatevectorEstimator, StatevectorSampler

sampler = StatevectorSampler(seed=23)
estimator = StatevectorEstimator(seed=23)

These implementations use local statevector simulation and do not model backend noise. Sampler is finite-shot; zero-precision Estimator is exact only for unitary state preparation.

Memory for a dense statevector grows as \(2^n\). Use an algorithm-appropriate Aer method or tensor-network tooling for larger circuits.

Aer Simulation

Install the pinned Aer distribution:

uv pip install "qiskit-aer==0.17.2"

Create an ideal Aer backend:

from qiskit_aer import AerSimulator

aer = AerSimulator(method="automatic")

Run through Runtime's local-testing primitive interface:

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime.executor_sampler import Sampler

pass_manager = generate_preset_pass_manager(
    backend=aer,
    optimization_level=1,
    seed_transpiler=23,
)
isa_circuit = pass_manager.run(circuit)

sampler = Sampler(
    mode=aer,
    options={"simulator": {"seed_simulator": 23}},
)
result = sampler.run([isa_circuit], shots=1024).result()

The Runtime 0.50 client-side primitives perform preprocessing and postprocessing locally, including enabled mitigation/twirling paths. This differs from deprecated server-side primitives whose local mode ignored many options. Use resilience_level=0 for an unmitigated Estimator baseline and inspect finalized options. Local results still do not verify service limits, scheduling, costs, or QPU mitigation effectiveness. dry_run=True on a remote backend is a server job returning random mock data, not Aer simulation.

Approximate a Real Backend in Aer

from qiskit_aer import AerSimulator

noisy_aer = AerSimulator.from_backend(backend)
pass_manager = generate_preset_pass_manager(
    backend=noisy_aer,
    optimization_level=1,
    seed_transpiler=23,
)
noisy_isa = pass_manager.run(circuit)

sampler = Sampler(
    mode=noisy_aer,
    options={"simulator": {"seed_simulator": 23}},
)
result = sampler.run([noisy_isa], shots=4096).result()

This captures a subset of backend properties at model-construction time. It does not reproduce drift, all crosstalk, or every Runtime service behavior.

Fake Backends

Fake backends provide a local BackendV2 target and calibration-like snapshot:

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

fake_backend = FakeSherbrooke()

Use them to test target-aware transpilation and Runtime local mode. Fake-backend class names can change; inspect the installed qiskit_ibm_runtime.fake_provider module before selecting one.

Estimator Noise Management

Runtime Estimator exposes increasing levels of built-in mitigation:

from qiskit_ibm_runtime.executor_estimator import Estimator

estimator = Estimator(
    mode=backend,
    options={"resilience_level": 1},
)

Current supported resilience levels:

• 0: disable built-in resilience.
• 1: measurement mitigation.
• 2: measurement mitigation plus additional techniques such as ZNE, according to current defaults.

There is no resilience level 3 in the current V2 API.

Configure explicit techniques when the experiment requires control:

estimator = Estimator(mode=backend)
estimator.options.dynamical_decoupling.enable = True
estimator.options.dynamical_decoupling.sequence_type = "XpXm"

estimator.options.twirling.enable_gates = True
estimator.options.twirling.num_randomizations = 32
estimator.options.twirling.shots_per_randomization = 100

estimator.options.resilience.zne_mitigation = True
estimator.options.resilience.zne.noise_factors = (1, 3, 5)
estimator.options.resilience.zne.extrapolator = "exponential"

Mitigation adds bias assumptions, circuit variants, shots, classical processing, and cost. It is not guaranteed to improve an observable.

Sampler Noise Management

Sampler returns sampled classical data and does not use Estimator resilience levels:

sampler = Sampler(mode=backend)
sampler.options.dynamical_decoupling.enable = True
sampler.options.dynamical_decoupling.sequence_type = "XpXm"
sampler.options.twirling.enable_gates = True

Measurement and gate-twirling defaults differ between Sampler and Estimator. Record primitive.finalize_options().model_dump() for the client-side implementation. Measurement mitigation forces measurement twirling; gate-based mitigation can force both. Explicitly enabled methods can override the meaning of resilience_level=0.

Feature Compatibility

Some combinations are restricted. Current examples include incompatibilities among:

• fractional gates,
• gate twirling,
• probabilistic error amplification (PEA),
• probabilistic error cancellation (PEC),
• gate-folding zero-noise extrapolation (ZNE),
• some dynamic-circuit features.

Client-side Sampler 0.50 rejects input BoxOp circuits (including with twirling enabled in the tested wheel); dynamical decoupling rejects dynamic control flow. This is stricter than the current Sampler page, which only mentions boxes when twirling is disabled. Always consult the current Estimator/Sampler options and backend target. Do not copy a mitigation configuration between Runtime versions without revalidation.

Fractional Gates

Request a backend target that exposes fractional gates when the algorithm benefits:

backend = service.backend(
    backend_name,
    use_fractional_gates=True,
)

Compile against the returned object. use_fractional_gates changes the target and can affect compatibility with control flow and mitigation.

Qiskit Pulse is not an alternative; qiskit.pulse was removed in Qiskit 2.0.

Third-Party Providers

Qiskit can target non-IBM providers through separately installed provider packages. Each provider controls:

• authentication,
• backend discovery,
• supported BackendV2 features,
• whether native V2 primitives exist,
• transpilation plugins,
• result and cost semantics.

Prefer the provider's current documentation. If only BackendV2 is available, adapt it with BackendSamplerV2 or BackendEstimatorV2. Do not assume IBM Runtime options, sessions, or mitigation are portable.

Operational Checklist

Before submitting:

1. Verify the account, plan, instance, and region.
2. Select a backend by circuit width and capabilities.
3. Compile and test locally against a fake/noisy backend.
4. Apply the circuit layout to Estimator observables.
5. Estimate the number of PUBs, circuits after randomization/mitigation, shots, and maximum execution time.
6. Choose job, batch, or session mode.
7. Save job IDs immediately.
8. Store versions, backend, target timestamp, compiler seed, primitive options, and metadata.

Common Failures

• Authentication failure: use ibm_quantum_platform, verify the saved account, API key, and instance access.
• Backend not found: list accessible backends; systems and account entitlements change.
• Circuit not ISA-compatible: submit the circuit returned by the backend-specific pass manager.
• Open Plan session error: use job or batch mode.
• Unsupported option combination: check the current feature-compatibility table.
• Unexpected queue/cost: inspect the plan, mode TTL, precision, shots, mitigation, and twirling expansion.
• Simulation differs from QPU: document the model snapshot and unmodeled effects rather than tuning until outputs match.