Cross-Device Quantum Error Mitigation

• Cross-device QEM is defined as techniques that adapt noise correction models across different quantum devices by using device-specific calibration and topology data.
• The approach employs few-shot learning, attention-based architectures, and hybrid methods combining extrapolation and regression to correct for variable hardware error profiles.
• Portable mitigation primitives enable the transfer from physical noise models to logical-layer corrections, improving fidelity and operational overhead across diverse platforms.

Cross-device quantum error mitigation denotes a family of techniques that seek to preserve mitigation performance when the hardware changes. In the narrow sense used in transfer-learning studies, it means learning how noise distorts measurement outcomes on one physical quantum device and then re-using that learned noise model on another device, adapting it with only a small number of additional experiments so that noisy measurement distributions on the new device can be denoised toward the ideal distribution (Farib et al., 27 Apr 2026). In a broader sense, the term also covers hardware-agnostic mitigation primitives whose control logic, extrapolation rule, graph representation, or logical-layer interface can be instantiated on different platforms once device-specific calibration data, noise-scaling procedures, or decoder outputs are supplied (Shi et al., 2024, Sohn et al., 2024, Zhou et al., 10 Dec 2025).

1. Conceptual scope and problem structure

Cross-device QEM arises because noise in the NISQ regime is strongly device-specific: coherence times, gate fidelities, readout errors, crosstalk, and temporal drift vary across backends, so a mitigation strategy calibrated on one processor often degrades when deployed unchanged on another (Farib et al., 27 Apr 2026, Cirstoiu et al., 2022). The literature therefore separates two questions. The first is whether mitigation knowledge can be transferred across devices by learning a reusable prior and adapting it with little target-device data. The second is whether a mitigation method is portable in the weaker sense that its abstract workflow is hardware-agnostic even though every new backend still requires fresh calibration, folding schedules, or decoder parameters (Shi et al., 2024, Cirstoiu et al., 2022).

This distinction explains why “cross-device” has several operational meanings. In supervised-learning work, the source and target devices are distinct IBM backends, and the central issue is zero-shot or few-shot transfer of a learned map from noisy to ideal output distributions (Farib et al., 27 Apr 2026, Placidi et al., 20 Jan 2026). In benchmarking work, the same mitigation protocol, circuit families, compilation pipeline, and shot budget are evaluated on multiple devices to determine where mitigation is actually beneficial, because performance on one superconducting backend does not reliably predict performance on another (Cirstoiu et al., 2022). In platform-portability studies of ZNE, the method is device-agnostic at the level of “measure at several effective noise levels and extrapolate to zero noise,” but practical success depends on hardware-specific noise amplification mechanisms such as gate folding or pulse stretching (Sohn et al., 2024). In fault-tolerant settings, the abstraction shifts again: once QEM is defined in terms of logical Pauli channels and decoder soft information, the right half of the QEM stack becomes portable across hardware implementations of the same logical code, while only the physical decoding layer remains device-specific (Zhou et al., 10 Dec 2025).

A recurring theme is that cross-device QEM is not a single algorithmic family but an interface problem between three layers: representation of circuit and calibration data, a mitigation rule or model, and a deployment protocol that specifies what must be relearned on the target device. The empirical record described here consistently rejects the strongest portability claim—namely that mitigation is plug-and-play across devices—but also shows that substantial reuse is possible when transfer is structured around the right invariants.

2. Learned transfer of noise models between physical devices

The clearest source-to-target formulation is the few-shot transfer study on two IBM superconducting devices, ibm_fez as source and ibm_marrakesh as target. There, error mitigation is posed as supervised learning of a map from noisy distributions, circuit descriptors, and calibration features to ideal distributions. Each circuit-backend sample is encoded as a vector in $\mathbb{R}^{41}$ containing scalar circuit statistics, standardized calibration summaries, and a padded noisy output distribution; the target is the padded ideal output distribution. The predictor uses a residual form,

$$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$

so the network learns a correction to the observed distribution rather than a distribution from scratch. Training minimizes KL divergence against the ideal distribution. On this dataset, zero-shot transfer from the source-trained model to the target device raises KL divergence from $0.3014$ in-domain to $1.6706$, establishing strong device specificity; with $K=20$ target-device fine-tuning samples, KL falls to $1.1924$, a $28.6\%$ improvement over zero-shot and a recovery of $34.9\%$ of the zero-shot to in-domain gap (Farib et al., 27 Apr 2026).

The same study is important because it identifies what fails under transfer. The source and target devices do not differ by a uniform rescaling of noise: ibm_marrakesh has higher $T_1$ and $T_2$ but substantially worse CX and readout error, including a $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$0 increase in CX gate error. The authors therefore treat cross-device mitigation not as domain adaptation on superficially similar data, but as re-calibration of a structured noise-correction map conditioned on hardware metadata. Few-shot adaptation uses replay from source-device data to avoid catastrophic forgetting and updates only the output head for very small target sets, unfreezing deeper layers only when more target examples are available (Farib et al., 27 Apr 2026).

A second line of evidence comes from the study of deep learning approaches to QEM on ibm_algiers and ibm_hanoi, two IBM 27-qubit transmon QPUs of the same generation. Here the task is again full-distribution mitigation for 5-qubit circuits, but the architectural comparison is broader: MLPs, RNNs, Transformers, encoder-only attention, and Perceiver variants are trained on circuit encodings, backend features, and noisy distributions. The principal empirical conclusion is that sequence-to-sequence, attention-based prediction models are the most robust, and that “generalization performance across similar devices with the same architecture works effectively, without needing to fully retrain models.” In the transfer configurations evaluated on ibm_hanoi, all configurations achieved performance comparable to ibm_algiers, with no significant degradation; the transfer-learning setup was slightly more stable for attention-based models (Placidi et al., 20 Jan 2026).

Taken together, these studies define the present empirical boundary of learned cross-device QEM on real hardware. Direct zero-shot reuse of a learned model can fail badly when two-qubit error structure changes materially, but transfer is not futile: attention-based or residual models can exploit the noisy distribution itself as a strong denoising signal, and a small amount of target-device supervision can recover a significant fraction of lost performance (Farib et al., 27 Apr 2026, Placidi et al., 20 Jan 2026).

3. Calibration features, topology, and localized noise structure

A central issue in cross-device mitigation is which hardware descriptors carry transferable information and which instead encode device-specific mismatch. In the few-shot transfer study, leave-one-out calibration ablations show that mean $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$1 and mean $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$2 contribute negligibly to zero-shot transfer, while readout error and especially CX gate error dominate the mismatch. In the zero-shot A$$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$3B setting, removing the readout-error feature lowers KL from $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$4 to $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$5, and removing the CX gate-error feature lowers it to $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$6; removing $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$7 or $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$8 changes KL by less than $$\hat{\mathbf{y}}=\mathrm{softmax}\!\bigl(\mathbf{x}_{\text{noisy}}+f_\theta(\mathbf{x})\bigr),$$9. The interpretation given there is that the learned source-device mapping from calibration features and circuit structure to distributional distortion becomes misleading when the target-device two-qubit error regime differs qualitatively from the source (Farib et al., 27 Apr 2026).

This emphasis on local hardware structure also appears in graph-based mitigation. In the graph-enhanced mitigation framework, circuits are encoded as attributed physical graphs whose nodes are physical qubits and whose edges are physical couplings. Node features include local calibration data such as $0.3014$0, $0.3014$1, and readout error; edge features encode two-qubit gate error rates. A message-passing GNN is then used to model error propagation along the actual coupling graph, followed by a dual-branch affine correction that preserves identity at initialization. This representation was designed to support portability by moving device dependence into graph structure and calibration features rather than into separate model parameters for each backend. Although the paper explicitly demonstrates zero-shot transfer across system size rather than across chips, the mechanism is directly relevant to cross-device QEM: the same message-passing rules can be reused on a different graph with different node and edge features. In the reported 10-qubit to 16-qubit zero-shot transfer, GEM achieved mean MAE $0.3014$2 against $0.3014$3 for CDR and $0.3014$4 for the edge-ablated variant, showing that coupling information is materially important for generalization (Wang et al., 18 Apr 2026).

Measurement noise exhibits the same locality principle. “Coupling Map Calibration” exploits the observation that correlated readout errors on IBM superconducting devices are physically localized on the coupling map. Instead of learning a full $0.3014$5 measurement channel, it calibrates local overlapping patches tied to nearby qubits and joins them as a series of sparse matrices. This design explicitly targets state-dependent and correlated measurement errors that violate the naive tensor-product readout model, and it is evaluated across multiple IBM devices. The reported experiments show up to a $0.3014$6 reduction in the error rate without increasing the number of device executions relative to conventional mitigation methods (Robertson et al., 2022).

These results give a consistent picture. Device transfer is easiest when the mitigation model represents noise in the same locality structure in which hardware errors are organized: two-qubit gate infidelities on couplers, readout correlations on neighboring qubits, and drift summarized by current calibration features. Aggregated coherence times alone appear too weak, whereas topology-aware encodings and edge-level errors capture a large part of what changes across devices (Farib et al., 27 Apr 2026, Wang et al., 18 Apr 2026, Robertson et al., 2022).

4. Portable mitigation primitives and hybrid cross-platform methods

A second branch of the literature does not transfer a learned model from one backend to another, but instead develops QEM primitives whose logic is portable across hardware. ZNE is the canonical case. Its core prescription—measure an observable at several effective noise levels and extrapolate to zero noise—is hardware-agnostic, but practical deployment is determined by the choice of noise amplification method and by whether the device’s dominant noise approximately respects the assumptions behind extrapolation (Sohn et al., 2024). On a silicon spin-qubit platform dominated by $0.3014$7 charge noise and non-Markovianity, three amplification methods were studied: global folding, local folding, and pulse stretching. Global folding-based ZNE, combined with readout mitigation, improved single-qubit state tomography fidelities to $0.3014$8 and $0.3014$9 from unmitigated fidelities of $1.6706$0 and $1.6706$1, and the paper explicitly presents this as evidence that ZNE is adaptable to quantum computing platforms with different noise characteristics through appropriate amplification choices (Sohn et al., 2024).

The same portability issue appears in selected-ZNE for QRAM. There, the mitigation target is not a single expectation value but the full collection of tomography probabilities entering reconstruction of a 4-qubit reduced state. The method fits multiple extrapolation models per outcome probability and either selects among them using an external noisy estimator or applies a stand-alone filter function. On ibm_cairo, filter-based sZNE raised QRAM fidelity from $1.6706$2 to approximately $1.6706$3, while the noisy-estimator version with perfect guidance increased fidelity to approximately $1.6706$4. The notable technical point is that only $1.6706$5 of $1.6706$6 expectation values became individually closer to ideal under the filter method, yet overall state fidelity improved. This makes cross-device QEM explicitly application-metric-centric: per-outcome adaptivity and selection rules can transfer across platforms even when no single extrapolation model works uniformly across observables (Shi et al., 2024).

Hybridization is another route to portability. Extrapolated CDR combines ZNE-style scaling with CDR-style regression by learning a linear noisy-to-ideal map at several noise scales and then extrapolating the regression coefficients themselves to zero noise. In the experimental multi-layer quantum routing benchmark on IBM superconducting hardware, eCDR significantly outperformed ZNE and CDR for the 2-layer quantum router, while naive serial combinations such as ZNE+CDR and CDR+ZNE did not match it. This is a device-portable pattern because the abstraction lives at the level of “noise-scaled regression coefficients” rather than at the level of a particular backend’s microscopic noise model (Shi et al., 2024).

Pulse-level inverse-evolution methods pursue portability through control theory rather than extrapolation. Adaptive KIK constructs a pulse-based inverse evolution $1.6706$7 so that a KIK cycle $1.6706$8 mirrors the noise of the forward evolution, then combines observables from $1.6706$9 using analytic coefficients that depend on a single scalar survival parameter. The method is presented as experimentally simple, independent of system size in the number of distinct circuits required, and able to handle spatially correlated and time-dependent noise, including execution spread over days despite drift and recalibration (Henao et al., 2023).

Finally, generalized quantum subspace expansion broadens the notion of a transferable primitive. In the fault-subspace construction, the basis elements are noisy states $K=20$0 generated at different noise levels, and the effective mitigated state is built from a variational combination of these states. The paper explores hardware-oriented ways to generate that basis—intentional amplification of decoherence, identity insertion, crosstalk, and probabilistic implementation of a noise channel—showing that a cross-device mitigation basis need not be limited to one amplification mechanism or one phenomenological noise parameter (Ohkura et al., 2023).

5. Cross-device benchmarking and the measurement of benefit regions

Portable algorithms are not sufficient; the literature also develops cross-device benchmarking frameworks that expose when mitigation helps and when it does not. The most systematic example is volumetric benchmarking with Qermit. There, circuit classes are indexed by width $K=20$1 and depth $K=20$2, the same logical circuits are compiled to multiple superconducting devices via a common pytket pipeline, and mitigation performance is summarized by the relative error of mitigation

$K=20$3

This metric makes the device comparison operational: $K=20$4 means mitigation helped, and volumetric plots over $K=20$5 reveal the “benefit region” of a method for a given device and circuit family (Cirstoiu et al., 2022).

The striking empirical result is that even nominally similar devices can have materially different mitigation behavior. ibmq_casablanca and ibm_lagos have the same 7-qubit topology and broadly comparable average calibration parameters, yet ZNE is significantly worse on ibm_lagos, especially for Pauli-gadget circuits, whereas CDR is more consistent across both devices. Moreover, calibrated emulators that include depolarizing, thermal relaxation, readout error, the real coupling map, and native gate set still overestimate hardware performance. The paper therefore argues that simple noise models and even realistic emulators are too optimistic for cross-device prediction; the same protocol can exhibit different benefit regions on different devices, and median improvement can hide worst-case failure (Cirstoiu et al., 2022).

Measurement-layer benchmarking reaches a similar conclusion from a different angle. Coupling-map-constrained readout mitigation performs well when the device’s actual readout correlation structure is aligned with the hardware coupling map, but CMC-ERR—where an empirical “error map” is built from the strongest pairwise readout correlations—can outperform plain CMC on devices whose dominant readout correlations do not follow the physical gate connectivity. In other words, even when the mitigation protocol is portable, the graph on which it should operate may be device-specific and empirically discovered rather than inherited directly from the backend topology (Robertson et al., 2022).

The benchmark literature therefore changes the meaning of “cross-device” from “can be transferred” to “can be measured on a common scale.” Its main conclusion is methodological: cross-device QEM requires device-adaptive validation, not only because hardware differs, but because the same mitigation overhead can be worthwhile on one backend and counterproductive on another (Cirstoiu et al., 2022, Robertson et al., 2022).

6. Logical-layer portability in the fault-tolerant regime

Cross-device QEM is not confined to NISQ distribution denoising. In the fault-tolerant regime, the abstraction can move to the logical layer, where device dependence is compressed into decoder outputs. The key object is decoder soft information: for a syndrome $K=20$6, the posterior probability that the residual logical effect is a logical Pauli $K=20$7 is

$K=20$8

Averaging these posteriors over shots yields an unbiased estimator of the logical Pauli channel induced by a given gadget, and the resulting logical channel description can be consumed by post-selection, probabilistic error cancellation, and logical-level ZNE without additional hardware modifications or extra characterization circuits (Zhou et al., 10 Dec 2025).

This is cross-device in a particularly strong sense. Once the decoder supplies posterior vectors over logical error classes, the QEM layer no longer depends on the underlying physical implementation—superconducting, trapped-ion, neutral-atom, or otherwise—except through the decoder’s noise prior and the estimated logical rates. The paper argues that the same logical-level QEM protocol can be reused across hardware platforms implementing the same logical code and soft-output decoder API. On a surface-code architecture with tensor-network and MWPM-based decoders, the reported methods reduced logical error rates by more than $K=20$9 while discarding fewer than $1.1924$0 of shots, and resource studies reported up to $1.1924$1 spacetime-overhead savings relative to QEC-only baselines (Zhou et al., 10 Dec 2025).

The significance for encyclopedia-level classification is that cross-device QEM admits two qualitatively different notions of invariance. In NISQ work, the invariant is partial reuse of a noisy-to-ideal map under changing calibrations and couplers. In logical-layer work, the invariant is the decoder interface itself: once logical Pauli rates are estimated in situ, the mitigation algorithms consume only those logical rates. This creates a natural standardization layer in which portability is defined not by similar raw hardware noise, but by compatibility of the logical-code and decoder stack (Zhou et al., 10 Dec 2025).

7. Limitations, open problems, and emerging directions

The current evidence base remains narrow in several respects. The most direct few-shot transfer study uses only two IBM superconducting devices and circuits on 2–5 qubits with depths 2–8, so transfer across more heterogeneous backends, larger circuits, or other hardware platforms is untested in that setting (Farib et al., 27 Apr 2026). The deep-learning study that demonstrates effective cross-QPU generalization is also restricted to 5-qubit full output distributions on two IBM devices of the same generation, and it explicitly notes that the exponential dimensionality of full distributions will create scaling challenges beyond that regime (Placidi et al., 20 Jan 2026). The graph-based GEM study establishes zero-shot transfer across system size, but not yet cross-chip or cross-platform transfer, and it assumes that local noise propagation along the coupling graph captures the dominant structure (Wang et al., 18 Apr 2026).

The benchmark literature is equally cautionary. Volumetric benchmarking shows that mitigation is not a plug-and-play black box with predictable behavior across backends, even when topology and average calibration statistics are similar (Cirstoiu et al., 2022). ZNE-based portability studies warn that digital or analog noise scaling is only reliable when the hardware admits an effective scalar noise parameter; coherent errors, SPAM that is not scaled by folding, and non-Markovian environments can invalidate naive extrapolation or make higher-order fits unstable (Shi et al., 2024, Sohn et al., 2024). Logical-layer QEM, for its part, still leaves realistic circuit-level noise, leakage, model mismatch, and scalable soft-output decoding as open issues (Zhou et al., 10 Dec 2025).

The research directions proposed across these papers are correspondingly convergent. One set of directions seeks richer representations of device state: per-qubit and per-edge calibration features, topology-aware encoders, temporal modeling of drift, and meta-learning or fast adaptation procedures for new devices (Farib et al., 27 Apr 2026, Wang et al., 18 Apr 2026). A second set seeks broader empirical coverage: more IBM devices, more platforms, deeper circuits, and benchmark maps that determine benefit regions under fixed resource budgets rather than under idealized simulation assumptions (Cirstoiu et al., 2022, Shi et al., 2024). A third set moves upward in abstraction: hybrid mitigation schemes that combine readout correction, extrapolation, regression, learned surrogates, and eventually decoder-informed logical QEM (Shi et al., 2024, Zhou et al., 10 Dec 2025).

What emerges from the literature is a layered conception of cross-device quantum error mitigation. At the physical level, transfer succeeds only when device-specific structure—especially two-qubit error and localized readout correlations—is represented explicitly. At the methodological level, portability is strongest for mitigation primitives whose abstract logic is independent of the hardware but whose instantiation is calibrated per backend. At the logical level, portability can become much stronger, because the mitigation layer consumes decoder-derived logical channels rather than hardware-native noise directly. This suggests that the long-term development of cross-device QEM will depend less on universal black-box denoisers than on progressively cleaner interfaces between calibration, topology, mitigation, and, eventually, decoding (Farib et al., 27 Apr 2026, Cirstoiu et al., 2022, Zhou et al., 10 Dec 2025).