When a phone or robot estimates its indoor position from Wi-Fi or Bluetooth signal strengths, two different things can make the answer wrong. The radio environment can be bad: walls, people and reflections distort the signal. When the estimator is a small quantum circuit running on today's error-prone quantum processors, the hardware itself adds a second source of error. Its qubits lose their state, its gates over-rotate, and its calibration drifts from day to day. Current quantum localization work reports a single error number and cannot say which source caused a bad fix. It has also only been tested at a scale (three signal sources, three qubits) where hardware noise is still mild. We propose to model the hardware's contribution directly. The idea is to learn, with a Gaussian process (a Bayesian regression model that returns both a prediction and a calibrated error bar), the discrepancy between what the circuit outputs in a noise-free simulator and what it outputs on the real device, as a function of the input and of time. That discrepancy model then corrects the hardware output, and it splits the predictive uncertainty into a "radio" part and a "qubit" part.
The main scientific payoff is a measurement, and it may not be a positive result for quantum computing. The literature has an unresolved tension here. Hybrid Quantum Neural Network based Indoor User Localization using Cloud Quantum Computing runs a 3-qubit hybrid network on IBM hardware and reports that its outputs track ideal simulation closely. RoQNN: Noise-Aware Training for Robust Quantum Neural Networks reports accuracy drops of over 60% between simulation and IBM hardware for only slightly larger classifiers. A per-query discrepancy model, run as the circuit grows from 3 to 16 qubits, tells us where hardware error overtakes radio error. It also tells us whether a well-tuned classical scalable Gaussian process makes the quantum model pointless at every scale.
Core Claim
Hardware noise in variational circuits is largely systematic. RoQNN reports that it scales and shifts measurement statistics, and Evolutionary Quantum Architecture Search for Parametrized Quantum Circuits finds that it shifts and flattens the loss landscape rather than adding zero-mean jitter. Because the noise is systematic, we claim it can be learned from a small number of paired simulator/hardware runs and subtracted.
We write the hardware measurement vector for input $x$ at time $t$ as
$$ z_{hw}(x,t) = z_{sim}(x) + \delta(x,t) + \epsilon , $$
where $z_{sim}$ is the noise-free circuit output, $\delta$ is the hardware discrepancy modeled by a Gaussian process over input and time, and $\epsilon$ is shot noise. Passing this through the classical output layer (with Jacobian $J$) gives a position covariance
$$ \Sigma_{pos}(x,t) = \Sigma_{env}(x) + J\,\Sigma_{\delta}(x,t)\,J^{\top}, $$
where $\Sigma_{env}$ is the radio-environment uncertainty and $\Sigma_\delta$ is the discrepancy posterior covariance. What is new is not "Gaussian processes for localization," which is old (Wireless Indoor Localization Using Convolutional Neural Network and Gaussian Process Regression, Gaussian Process Regression Plus Method for Localization Reliability Improvement). What is new is a time-aware discrepancy process that makes the simulation-to-hardware gap visible and correctable for each query, together with a scaling study that uses it as an instrument.
Relation to Prior Work
The closest method is SPSA+AL in Error mitigation in variational quantum eigensolvers using tailored probabilistic machine learning. It fits an exact Gaussian process with an ansatz-matched Fourier prior to noisy energy readouts and only calls the processor when the model is uncertain, cutting hardware evaluations from 302 to 61 on an 8-site Heisenberg model. We borrow its "query hardware only where uncertain" logic. We differ in three ways. Our model targets the difference between hardware and simulator, not the objective itself. Its inputs are sensor data rather than circuit parameters. And it must follow drift over days rather than over one optimization run.
Scalable Gaussian processes supply the machinery rather than the motivation. Recurrent Memory for Online Interdomain Gaussian Processes (OHSVGP) updates a sparse Gaussian process recursively along a time axis without forgetting old data. Its main weakness, dependence on an artificial ordering for non-temporal data, does not bite here, because hardware drift is genuinely temporal. Its other weakness, frozen kernel hyperparameters, does bite, since recalibration events may change the discrepancy's structure. We test this directly. For the radio term $\Sigma_{env}$ we use the nearest-neighbor Gaussian process of Leveraging Locality and Robustness to Achieve Massively Scalable Gaussian Process Regression (GPnn), which scales to millions of points with calibrated variances. Its known degradation above roughly 50 input dimensions means we work on compressed signal-strength features, not all 520 access points.
Other work constrains the design. Profiling quantum circuits for their efficient execution on single- and multi-core architectures and QMLP: An Error-Tolerant Nonlinear Quantum MLP Architecture using Parameterized Two-Qubit Gates show that uniform noise models miss crosstalk and non-uniform qubit quality. For this reason the discrepancy model conditions on the actual qubit layout and calibration snapshot, and we never train it on uniform depolarizing simulation alone. The quantum-algorithm Gaussian process papers (Quantum algorithm for Gaussian process regression, Quantum-Assisted Gaussian Process Regression Using Random Fourier Features) go the other direction, using quantum hardware to speed up Gaussian processes. They are untested on noisy devices, and we do not build on them.
Research Program
We first reproduce the hybrid network of Mittal et al.: a ZZ feature map (a circuit that encodes each input value into qubit rotations with pairwise entangling terms), a RealAmplitudes trainable circuit, and a 32-unit classical head. We build it in TorchQuantum (TorchQuantum Case Study for Robust Quantum Circuits) and train it in noise-free simulation. We then widen the input to $k \in \{3,4,6,8,12,16\}$ qubits by feeding it the top-$k$ principal components of UJIIndoorLoc signal strengths, after removing uninformative access points as recommended in On the Use and Construction of Wi-Fi Fingerprint Databases for Large-Scale Multi-Building and Multi-Floor Indoor Localization: A Case Study of the UJIIndoorLoc Database.
For each width we collect paired runs. The same inputs go through the simulator and through IBM hardware across several days, and we log the device calibration data (relaxation and dephasing times, gate and readout error, chosen physical qubits). Because hardware access is scarce, we use device-derived noise models for the full sweep. Real hardware is used for the 3-, 6- and 12-qubit points and for all drift experiments. Every figure will label which regime produced it.
The discrepancy process $\delta(x,t)$ takes the input features, calibration covariates, and time as inputs. It is fit with OHSVGP along time, and new hardware queries are selected by posterior variance under a fixed daily shot budget. The radio term comes from GPnn fit to the same features, with post-hoc variance calibration. The simulator-side model and the discrepancy model are trained on disjoint data so the decomposition is not circular.
Baselines
The naive reference point is the simulator-trained hybrid network deployed on hardware with no correction and no uncertainty. This is exactly the protocol of Mittal et al. On their Scenario 3 Zigbee benchmark they report 1.298 m RMSE for the hybrid network, 1.306 m for a classical network, and 2.616 m for static quantum fingerprinting. We rerun all three on Sc-1 to Sc-3 with identical splits so that the 0.008 m gap between quantum and classical can be judged against seed-to-seed variance, which the paper does not report.
The strongest competitor on the localization question is a purely classical scalable Gaussian process: GPnn on the same $k$ features. It is fit with the same data and tuned with the same budget of hyperparameter trials (twenty per method) as the quantum pipeline. For GPnn on these localization datasets we found no reported result on Lacuna, so we will produce it. On full-feature UJIIndoorLoc, the reference numbers are 9.5 m mean error for CAE-CNNLoc (CAE-CNNLoc: An Edge-based WiFi Fingerprinting Indoor Localization Using Convolutional Neural Network and Convolutional Auto-Encoder) and 8.54 m for the filtered recurrent network in the UJIIndoorLoc case study. These use far more input information than a $k$-qubit model, so they bound what is achievable rather than serving as a like-for-like comparison. We will also run GPnn on full-dimensional compressed features to place it against them. The quantum pipeline "beats" the classical Gaussian process at width $k$ only if both of the following hold. Its hardware RMSE must be lower by more than the 95% bootstrap interval across seeds and days. And its 90% intervals must cover within two points of nominal.
The strongest existing hardware-noise method is QuantumNAT from RoQNN. It combines per-qubit normalization of measurements, noise injection during training, and output quantization, and it improves hardware classification by up to 43%. No regression or localization result for it is reported on Lacuna. We apply it to the same circuits and calibrations. Our correction beats it if hardware RMSE is lower at equal hardware shots, including the shots our method spends on paired runs.
Two ablations isolate the key ingredient. The first replaces the Gaussian process discrepancy with a per-qubit affine shift-and-scale fit on the same paired runs. The second drops the time axis and calibration covariates, so the discrepancy model becomes static.
Why not just…?
Why not just use a classical Gaussian process and skip the quantum circuit? This is the most serious threat, and the proposal is built to confront it. The only quantum advantage in the file is 1.298 m versus 1.306 m on three inputs. We fully expect GPnn to match or beat the quantum pipeline at most widths. If it does at every width, that is the headline result: a calibrated, scaled refutation of the resilience claim. The discrepancy model is then still useful as the instrument that shows why, namely how much of the hardware error is qubit-caused.
Why not just correct with a per-qubit affine shift, as RoQNN's normalization implies? RoQNN's own finding that noise mostly scales and shifts outputs suggests this might work, and we take it seriously. The ablation settles it. If affine correction matches the Gaussian process in RMSE, we keep only the Gaussian process's claimed advantages: uncertainty and drift tracking. We test those by checking whether a static affine fit degrades on later days while the time-indexed discrepancy does not.
Why not just estimate uncertainty by resampling shots or ensembling circuits? Shot resampling measures only the random part $\epsilon$. The file's evidence (RoQNN; Ding et al.) is that the damaging part is a systematic shift, which every resample shares, so bootstrap intervals will be confidently wrong. We compare interval coverage of shot bootstrap, a five-member circuit ensemble, and our decomposition on hardware. Our method should win on coverage specifically where the systematic shift is large.
Proposed Experiments
The first decisive check is the crossover curve. For each width $k$, we plot hardware RMSE of the uncorrected quantum model, the QuantumNAT model, the discrepancy-corrected model, and classical GPnn, all on UJIIndoorLoc-derived features and on Sc-1 to Sc-3 at $k=3$. The interesting outcome is the width at which uncorrected hardware error exceeds radio-limited error. We also want to know whether the correction pushes that width outward.
The second check is attribution. We inject controlled radio corruption, a 10 dBm perturbation following the CAE-CNNLoc protocol. Separately, we inject controlled hardware corruption by deliberately mapping the circuit onto the device's worst-calibrated qubits, following the Bandic et al. observation. We then ask whether the radio and qubit variance terms rise selectively, scored by the area under the ROC curve for identifying the corruption source.
The third check is drift. We train the discrepancy model on days 1 to 3 and evaluate on days 4 to 7, including at least one recalibration event. We compare OHSVGP, a static discrepancy fit, and the online sparse Gaussian process that OHSVGP was shown to beat, using negative log predictive density. This test also exposes the frozen-hyperparameter limitation: a spike at recalibration would show where re-estimation is needed.
The proposal fails cleanly if two things both happen. The affine correction must match the Gaussian process on RMSE, coverage and drift. And the attribution score must be near chance. In that case, simple normalization plus a classical Gaussian process is the right recommendation, and we will say so.
References
- Hybrid Quantum Neural Network based Indoor User Localization using Cloud Quantum Computing
- QuantumNAT: Quantum Noise-Aware Training with Noise Injection, Quantization and Normalization
- Evolutionary quantum architecture search for parametrized quantum circuits
- Wireless Indoor Localization Using Convolutional Neural Network and Gaussian Process Regression
- Gaussian Process Regression Plus Method for Localization Reliability Improvement
- Error mitigation in variational quantum eigensolvers using tailored probabilistic machine learning
- Recurrent Memory for Online Interdomain Gaussian Processes
- Leveraging Locality and Robustness to Achieve Massively Scalable Gaussian Process Regression
- Profiling quantum circuits for their efficient execution on single- and multi-core architectures
- QMLP: An Error-Tolerant Nonlinear Quantum MLP Architecture using Parameterized Two-Qubit Gates
- Quantum algorithm for Gaussian process regression
- Quantum-Assisted Gaussian Process Regression Using Random Fourier Features
- TorchQuantum Case Study for Robust Quantum Circuits
- On the Use and Construction of Wi-Fi Fingerprint Databases for Large-Scale Multi-Building and Multi-Floor Indoor Localization: A Case Study of the UJIIndoorLoc Database
- CAE-CNNLoc: An Edge-based WiFi Fingerprinting Indoor Localization Using Convolutional Neural Network and Convolutional Auto-Encoder