As quantum processors scale beyond 100 qubits, distinguishing software bugs from stochastic hardware noise becomes a critical diagnostic challenge. We present a neuro-fuzzy framework that addresses this attribution problem by combining Adaptive Neuro-Fuzzy Inference Systems (ANFIS) with physics-grounded feature engineering. We introduce the Bhattacharyya veto, a hard constraint calibrated to the empirically characterized noise floor of the device, which classifies as buggy any output distribution whose divergence from the ideal exceeds what the device's noise produces under normal operation. The framework is validated on two IBM Heron r2 processors. On ibm_fez, across 105 circuits spanning 17 algorithm families, it attains 89.5% accuracy (Wilson 95% CI [82.2, 94.0]) with no abstentions; every residual error is a bug whose ideal computational-basis distribution is identical to the intended circuit's, or whose divergence lies below the device's noise floor. On a held-out suite of 30 deeper circuits (ISA depth to 100) executed on ibm_kingston, with all thresholds frozen, it attains 96.7% effective and 93.3% strict accuracy. We resolve key ambiguities - such as distinguishing correct Grover amplification from bug-induced collapse - and identify fundamental limits of single-basis diagnostics, including a Z-basis blind spot where phase-only errors remain statistically invisible. The extracted rule base is analyzed rather than asserted: the learned rules reproduce the physics of the veto, of the Grover boundary, and of depth-dependent noise without any of them being hard-coded. This work establishes an interpretable diagnostic layer that prevents error mitigation from being applied to logically flawed circuits.
As quantum processors scale beyond 100 qubits, distinguishing software bugs from stochastic hardware noise becomes a critical diagnostic challenge. We present a neuro-fuzzy framework that addresses this attribution problem by combining Adaptive Neuro-Fuzzy Inference Systems (ANFIS) with physics-grounded feature engineering. We introduce the Bhattacharyya veto, a hard constraint calibrated to the empirically characterized noise floor of the device, which classifies as buggy any output distribution whose divergence from the ideal exceeds what the device's noise produces under normal operation. The framework is validated on two IBM Heron r2 processors. On ibm_fez, across 105 circuits spanning 17 algorithm families, it attains 89.5% accuracy (Wilson 95% CI [82.2, 94.0]) with no abstentions; every residual error is a bug whose ideal computational-basis distribution is identical to the intended circuit's, or whose divergence lies below the device's noise floor. On a held-out suite of 30 deeper circuits (ISA depth to 100) executed on ibm_kingston, with all thresholds frozen, it attains 96.7% effective and 93.3% strict accuracy. We resolve key ambiguities - such as distinguishing correct Grover amplification from bug-induced collapse - and identify fundamental limits of single-basis diagnostics, including a Z-basis blind spot where phase-only errors remain statistically invisible. The extracted rule base is analyzed rather than asserted: the learned rules reproduce the physics of the veto, of the Grover boundary, and of depth-dependent noise without any of them being hard-coded. This work establishes an interpretable diagnostic layer that prevents error mitigation from being applied to logically flawed circuits.
Near-term quantum processors operate in the noisy intermediate-scale quantum (NISQ) region, where it is impractical to implement fault-tolerant error correction. Quantum Error Mitigation (QEM) provides a practical alternative, but most existing approaches rely on computationally intensive classical resources which are impractical to implement in embedded or edge-controlled systems. This work presents an adaptive, hardware-aware QEM framework designed for resource-constrained classical processors, demonstrated using a Raspberry Pi 5 as an edge controller for IBM Quantum hardware. A deep neural network predicts circuit fidelity and entropy from circuit and hardware features, enabling an online fuzzy-logic policy selector to choose among no mitigation, dynamical decoupling, and zero-noise extrapolation. Using real hardware feedback, an adaptive bias mechanism update policy was developed. The system operates without full-state simulation or offline recalibration and is evaluated on both randomized and benchmark-referenced circuits. Results show stable mitigation behaviour across depth regimes, primarily preventing fidelity degradation and selectively improving output similarity where mitigation is effective. This work demonstrates the feasibility of adaptive QEM deployment on classical edge devices under strict resource constraints.
Abstract Quantum computing has recently emerged as a novel paradigm for solving problems otherwise intractable on classical computers, yet the practical progress of quantum computers is severely impacted by noise, decoherence, and imperfect gate operations in Noisy Intermediate-Scale Quantum (NISQ) devices. Specific to IBM Quantum hardware, imperfections due to readout error, gate errors, and device drift, which depends on time, resolves limits for the accuracy of outputs from our algorithms. The mitigation strategies currently used, for example, Measurement Error Mitigation (MEM), Zero Noise Extrapolation (ZNE), and Clifford Data Regression (CDR), offer improvement over raw, unmitigated outputs, but they are static and not dynamic; the reduction of noise in within an NISQ device is temporal and can vary in patterns that are non-zero. In addition to this, using the conventional methods provides inconsistent and suboptimal results.This study will provide enhanced reliability with respect to performing quantum computation on IBM Quantum hardware with a unique mitigation framework that is adaptive and computationally efficient for a high-fidelity output. The problem taken on here is the failure of existing error mitigation strategies to provide adaptive noise compensation, as they assume a statically-distributed error, despite the performance-related characteristics already being documented in regards to calibration drift and variation over time.To achieve this, we propose a Hybrid Adaptive Error Mitigation (HAEM) approach that includes baseline measurement error mitigation and an additional correction layer that utilizes realtime calibration information, along with lightweight machine learning models. The approach can be broken down into three steps: (i) perform standard measurement error mitigation to reduce classical readout noise, (ii) execute compact calibration circuits, such as Bell states, GHZ states and Clifford benchmarks to capture then current error profile of the device, and (iii) use a lightweight machine learning model (having been trained on historical and newest calibration data) to dynamically change the mitigation weights applied for the target quantum algorithm. All implementation is done using Qiskit Runtime to ensure low-latency execution, and we completed experiments on both Qiskit Aer noisy simulators and IBM Quantum devices.Initial results suggest HAEM improved the outputs of quantum algorithms' fidelity compared to the unmitigated runs and the baseline measurement error mitigation (MEM) runs. On the noisy simulators, HAEM increased fidelity from a raw performance of 0.65 to 0.87, nearly a 34% improvement. In fairer hardware-like scenarios, fidelity-on-average was persistently 12% better than MEM, with nearly equal time duration for the additional adaptive measurements. The adaptive aspect of HAEM consistently supported subsequent calibration cycles of the device and was effective to continue providing fidelity improvements despite the static mitigation performance degrading.To sum up, the proposed HAEM framework is a modern and viable alternative for error mitigation which brings together the benefits of baseline approaches with corrections that are driven by fixed-function error-corrective, adaptive learning. As both learning-based and standard baseline approaches can only achieve fixed levels of performance, HAEM, through its use of noise mitigation both at execution time and through correlating it with standard data, provides a route towards reliable quantum computations on current IBM hardware. HAEM also presents a contribution to the NISQ error-resilient landscape, and however it is intended that it will continue to improve future applications of hybrid workflows of quantum and classical computation where error mitigation and resilience is important.
Maximizing the computational utility of near-term quantum processors requires predictive noise models that inform robust, noise-aware compilation and error mitigation. Conventional models often fail to capture the complex error dynamics of real hardware or require prohibitive characterization overhead. We introduce a data-efficient framework that first constructs a physically motivated, parameterized noise model, and subsequently employs machine-learning-driven Bayesian optimization to identify its parameters. Our approach circumvents costly characterization protocols by estimating algorithm- and hardware-specific error parameters directly from readily available experimental data derived from existing application and benchmark circuit executions. The generality and robustness of the framework are demonstrated across diverse algorithms and superconducting devices, yielding high-fidelity predictions by estimating an independent parameter set tailored to each specific algorithm-hardware context. Crucially, we show that a model calibrated exclusively on small-scale circuits accurately predicts the behavior of larger validation circuits. Our data-efficient approach achieves up to a 65% improvement in model fidelity quantified by the Hellinger distance between predicted and experimental circuit output distributions, compared to standard noise models derived from device properties. This work establishes a practical paradigm for application-aware noise characterization, enabling compilation and error-mitigation strategies tailored to the specific interplay between quantum algorithms and device-specific noise dynamics.
Abstract We introduce the K–R scaling exponent α, extracted from the three-parameter cost decomposition C = C₀/Kᵅ + R, as a compact diagnostic descriptor of error-accumulation regimes on noisy intermediate-scale quantum (NISQ) hardware. Here, C is the measured circuit infidelity, K is a structural parameter (inverse depth or inverse qubit count), C₀ is the correctable error amplitude, R is the irreducible noise floor, and α quantifies the rate of error accumulation. Through three experimental campaigns totaling approximately 150 circuit executions on two 156-qubit IBM Quantum Heron r2 processors (ibm_kingston and ibm_fez), we observe three distinct scaling regimes: (i) structured scaling with super-linear α in GHZ circuits (α = 1.54–1.64, R² > 0.97) and noise amplification (α = 1.19, R² = 1.000), consistent with correlated multi-qubit errors; (ii) controlled stochastic scaling in Clifford depth and echo circuits (α ≈ 0.5–0.7, R² up to 0.998); and (iii) saturation where α → 0. We organize these results in an (α, R²) phase diagram—the first such empirical diagram for quantum hardware noise—and demonstrate that α serves as a low-cost diagnostic observable enabling regime identification, device fingerprinting, and stability monitoring using fewer than 13 circuits per device. An honest comparison shows that for depth extrapolation, exponential models outperform K–R; however, K–R uniquely provides regime-level insight and device-specific behavioral signatures not accessible from exponential decay rates. By reducing quantum hardware characterization to a small set of experimentally accessible scaling parameters, the K–R framework provides a practical bridge between low-cost benchmarking and physically interpretable noise diagnostics in the NISQ era.
Quantum simulators are a foundational component of the quantum software ecosystem. They are widely used to develop and debug quantum programs, validate compiler transformations, and support empirical claims about correctness and performance. In the absence of large-scale quantum hardware, simulator outputs are often treated as ground truth for algorithm development and system evaluation. However, quantum simulators also introduce unique implementation challenges. They must faithfully emulate quantum behavior while executing on classical hardware, requiring complex representations of quantum state evolution, operator composition, and noise modeling. Yet, we still lack a large-scale and in-depth study of failures in quantum simulators.
To bridge this gap, this work presents a comprehensive empirical study of bugs in widely used open-source quantum simulators. We analyze 394 confirmed bugs from 12 simulators and manually categorize them based on root causes, failure manifestations, affected components, and discovery mechanisms. Our study reveals several key findings. First, bug discovery is largely user-driven, with most crashes, exceptions, and resource-related failures not detected by automated testing and identified after deployment. Second, logical correctness failures are widespread and often silent, producing plausible but incorrect outputs without triggering crashes or explicit error signals. Third, many critical failures originate in classical simulator infrastructure, such as memory management, indexing, configuration, and dependency compatibility, rather than in core quantum execution logic. These findings provide new insights into the reliability challenges of quantum simulators and highlight opportunities to improve testing and validation practices in the quantum software ecosystem.
Quantum computation has the promise to solve problems that are not efficiently solvable by classical means. Yet, due to the fragile nature of quantum states, it is unavoidable that quantum systems are subject to decoherence, gate imperfections, and measurement errors. These problems stand as a major roadblock to the construction of large-scale fault-tolerant quantum computers. Conventional quantum error correction (QEC) codes, such as the surface code or Shor code, need to use an extensive amount of redundancy and classical control, which can be both computationally expensive and challenging to scale. In this context, we propose to investigate the use of machine learning (ML) techniques by realizing on-line identification, localization and correction of these quantum errors for fault-tolerant quantum computation by means of fault-tolerant quantum computing processes. Our model introduces a hybrids ML-QEC architecture that combines classical neural networks and decision-tree classifiers with quantum syndrome decoding. These models are trained on error syndromes produced using the approximation of common noise models (for example, depolarizing noise, dephasing and amplitude damping), simulated under different QEC schemes. The machine learning methods are trained with quantum error patterns and have a capability to rapidly infer where errors are likely to occur, as well as recommend correction operations with high confidence. As a result, the system reduces dramatically the delay and computational costs when compared to conventional decoding methods. There is also a self-adaptive learning module in the work, which recommences training on fresh quantum error distributions, meaning the system can adapt to changes in the environment (and also the decay of the hardware) as time progresses. The study further carries out ML predictions inside a real-time loop and cross-checks them with quantum state tomography and entanglement fidelity such as indicators. Experimental characterization on dedicated devices as well as noise models show that our ML-enhanced decoders reach higher fidelity and lower logical error rates compared to baseline decoders, especially in non-uniform or time-dependent noise. This work is a significant stride towards realizing practical fault-tolerant quantum computation by combining quantum error correction with the versatility and scalability of machine learning. With intelligent models to dictate learning, our proposed framework is able to eliminate a lot of trial-and-error manual processes in the conventional heuristic-based approach, and points to a potential path to achieve scalable quantum information processing platforms.