Quantum Fuzzing Techniques

• Quantum fuzzing is a testing paradigm that systematically generates and mutates quantum inputs to explore diverse program behaviors using measurement feedback.
• It employs specialized mutation strategies on quantum circuits, parameter distributions, and hybrid inputs to enhance coverage and uncover failures.
• Empirical results indicate that guided fuzzing techniques significantly improve branch coverage, crash detection, and fault discovery over random approaches.

Quantum fuzzing is the systematic generation of “random” or semi-guided inputs to exercise as many behaviors of a quantum program under test as possible. In the literature represented here, the term spans several related settings: standalone quantum programs, where inputs may be quantum states or parameterized circuits; hybrid quantum–classical programs, where inputs are pairs of classical optimizer hyperparameters and quantum circuit parameters; and quantum neural networks, where fuzzing mutates classical inputs that are then amplitude-encoded into quantum states (Jin et al., 5 Sep 2025, Wang et al., 2018, Zhang, 14 May 2026, Shao et al., 2024). Across these settings, the central difficulty is that quantum programs exhibit superposition, entanglement, and probabilistic measurement, which make both coverage metrics and input spaces exponentially large (Jin et al., 5 Sep 2025).

1. Historical emergence and problem setting

The earliest framework in the material, QuanFuzz, is described as “the first greybox fuzzing approach for quantum programs” (Wang et al., 2018). It situates quantum fuzzing against classical fuzzing by observing that, in a quantum program, “branching” comes only after a measurement, since until the point of measurement the quantum state lives in superposition. QuanFuzz therefore defines quantum sensitive information in terms of the ket information immediately before measurement, the measurement operations on quantum registers, and the oracle or sensitive branches associated with particular measurement outcomes (Wang et al., 2018).

Subsequent work generalizes the target of fuzzing beyond single quantum programs. NovaQ treats quantum fuzzing as diversity-guided testing of a quantum program under test by generating diverse quantum state inputs and ranking them by internal quantum-state novelty (Jin et al., 5 Sep 2025). QCov extends the idea to parameterized quantum circuits that make up a QNN, emphasizing that coverage is measured not over control-flow edges but over statistics of quantum states, including basis-state probability distributions and multi-qubit entanglement (Shao et al., 2024). Failure-guided fuzzing for hybrid quantum-classical programs formalizes a hybrid input space $\mathcal{H} = \mathcal{C}\times\Theta$ and studies fuzzing under realistic execution budgets for VQE and QAOA (Zhang, 14 May 2026).

Taken together, these works define quantum fuzzing less as a single algorithmic family than as a testing paradigm. The common structure is a feedback loop between input generation and a quantum-specific guidance signal, but the guidance signal itself varies: branch-trigger probability in QuanFuzz, state-space novelty in NovaQ, crash-inducing seed reuse in hybrid programs, and state- or entanglement-based coverage in QNNs (Wang et al., 2018, Jin et al., 5 Sep 2025, Zhang, 14 May 2026, Shao et al., 2024).

2. Input representations and mutation spaces

A major axis of variation in quantum fuzzing is the representation of test inputs. In QuanFuzz, the seed input is a single $2^n\times 2^n$ complex unitary matrix $S$ applied at the very start of the quantum program under test. Mutation consists of right-multiplying $S$ by small unitary gates, specifically single-qubit gates $G\in\{H,X,Y,Z,S,T\}$, so that the maintained candidate input is a unitary $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$ (Wang et al., 2018). This choice makes the input itself a quantum operator rather than a classical datum.

NovaQ adopts a different representation. Its seed pool contains Gaussian distributions over the three parameters of the single-qubit $U$ gate, $U(\theta,\phi,\lambda)$, with each seed

$$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$

encoding means and variances for sampling $\theta,\phi,\lambda$ (Jin et al., 5 Sep 2025). For each qubit in the $2^n\times 2^n$0-qubit initial circuit, NovaQ samples these parameters, applies $2^n\times 2^n$1 to each qubit initialized to $2^n\times 2^n$2, appends a fixed Inverse Quantum Fourier Transform on all $2^n\times 2^n$3 qubits, and executes the circuit to obtain a state vector $2^n\times 2^n$4 (Jin et al., 5 Sep 2025). Mutation operates on the distribution parameters themselves: $2^n\times 2^n$5 with $2^n\times 2^n$6 and $2^n\times 2^n$7 sampled from $2^n\times 2^n$8 and $2^n\times 2^n$9 by default (Jin et al., 5 Sep 2025). A small fraction, 10%, may instead undergo a fully random reset with $S$0 and $S$1 (Jin et al., 5 Sep 2025).

Hybrid quantum-classical fuzzing models the input as

$S$2

where $S$3 are classical hyperparameters and $S$4 are quantum circuit parameters (Zhang, 14 May 2026). Its local fuzzing phase fixes the classical component and perturbs only the quantum parameters by isotropic Gaussian noise on the torus: $S$5 with $S$6 used in the reported experiments (Zhang, 14 May 2026).

QCov, by contrast, mutates classical images in pixel space using “pixel + affine metamorphic mutations,” including brightness, translation, and slight noise, and then re-encodes each mutant into a quantum state by amplitude encoding before circuit execution (Shao et al., 2024). This is notable because the mutations occur outside the circuit while the guidance signal is entirely quantum. A plausible implication is that “input” in quantum fuzzing is not fixed at one abstraction layer: it may be a unitary, a parameter distribution, a hybrid tuple, or a classical object whose semantics are transformed by quantum encoding.

3. Guidance signals: branch probability, novelty, failures, and coverage

Quantum fuzzing frameworks differ most sharply in what they optimize. QuanFuzz uses as its fitness the probability that a sensitive measurement result is observed. If $S$7 is the set of values that trigger a sensitive branch at a measurement site, and if

$S$8

then the fitness is

$S$9

QuanFuzz uses $S$0 both as a proxy for coverage and as a fitness score in search, always retaining the $S$1 candidate matrices with highest $S$2 until the best candidate exceeds a threshold $S$3 (Wang et al., 2018).

NovaQ replaces branch-directed search with novelty search over internal state metrics. Given

$S$4

it computes three continuous metrics from the final state vector: the magnitude metric

$S$5

the phase metric

$S$6

and the entanglement metric

$S$7

where $S$8 is the reduced density matrix of qubit $S$9 (Jin et al., 5 Sep 2025). These metrics are normalized, discretized into a $G\in\{H,X,Y,Z,S,T\}$0 grid, and assigned visitation counts. The novelty score is

$G\in\{H,X,Y,Z,S,T\}$1

so sparsely visited cells yield higher novelty (Jin et al., 5 Sep 2025). The framework therefore treats unexplored internal quantum-state regions as the object of optimization.

The hybrid failure-guided setting introduces a failure oracle rather than a conventional coverage function. Execution yields an objective $G\in\{H,X,Y,Z,S,T\}$2, and non-convergence is encoded by $G\in\{H,X,Y,Z,S,T\}$3, which depends on a target reference value $G\in\{H,X,Y,Z,S,T\}$4 and tolerance $G\in\{H,X,Y,Z,S,T\}$5 (Zhang, 14 May 2026). Phase I discovers crash-inducing seeds by random sampling, enumeration, or concolic execution; Phase II locally fuzzes quantum parameters around those seeds and aggregates crash counts under a fixed call budget (Zhang, 14 May 2026). The guidance signal is thus failure reuse: the search is biased toward regions already shown to be failure-prone.

QCov develops a family of explicit coverage criteria for QNNs. It defines k-cell State Coverage (KSC), State Corner Coverage (SCC), Top-k State Coverage (TSC), and k-cell Entanglement Coverage (KEC), all over the output state space of an $G\in\{H,X,Y,Z,S,T\}$6-qubit QNN (Shao et al., 2024). KSC discretizes the training-profile interval $G\in\{H,X,Y,Z,S,T\}$7 of each basis state into $G\in\{H,X,Y,Z,S,T\}$8 equal cells and measures the fraction of such cells hit by a test suite. SCC measures visits below $G\in\{H,X,Y,Z,S,T\}$9 or above $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$0. TSC measures how many basis states have ever been among the top-$M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$1 highest-probability states. KEC measures coverage over discretized intervals of the entanglement change ratio

$M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$2

where $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$3 is the Meyer–Wallach entanglement measure (Shao et al., 2024).

These four lines of work show that “coverage” in quantum fuzzing is not a settled notion. It may mean branch-trigger probability, visitation of internal metric cells, crash count under a failure oracle, or explicit state-space and entanglement criteria. This suggests that the field remains methodologically plural, with guidance defined by the testing objective rather than by a single standard metric.

4. Representative frameworks and workflows

QuanFuzz implements a search-based loop over a small priority queue. Starting from an initial seed matrix $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$4, it mutates each top-ranked matrix by applying randomly selected single-qubit gates on each qubit, computes the resulting $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$5, sorts candidates by descending fitness, truncates to the top $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$6, and stops when the best candidate crosses threshold $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$7 (Wang et al., 2018). The guidance by sensitive information is explicit: the only branches targeted are those guarded by tests of the form if (measure(q)==s), and the fitness is exactly the probability of sampling $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$8 (Wang et al., 2018).

NovaQ alternates between generation and selection. Starting with initial seeds $M\in U(2^n)\subset\mathbb{C}^{2^n\times 2^n}$9, it samples $U$0 circuits per seed, builds each circuit as $U$1, runs the circuit to obtain $U$2, computes novelty for each offspring, scores each seed by average offspring novelty, sorts seeds by descending score, retains the top $U$3, then applies guided mutation with probability 90% and randomization with probability 10% (Jin et al., 5 Sep 2025). The output is all test cases generated so far. Unlike QuanFuzz, it does not target a specific branch; it closes the loop between state-space novelty and the mutation of parameter distributions.

Failure-guided fuzzing for hybrid quantum-classical programs uses a two-phase workflow. Phase I discovers crash-inducing seeds in the hybrid space by one of three mechanisms: random sampling, systematic enumeration of the discrete classical space, or a lightweight SMT-backed concolic engine over integer encodings of $U$4 that records path constraints and flips one constraint at a time up to $U$5 new paths (Zhang, 14 May 2026). Seeds are ranked by severity

$U$6

and up to $U$7 seeds with distinct classical configurations are selected (Zhang, 14 May 2026). Phase II locally fuzzes the quantum parameters around each selected seed and measures crash statistics under a total budget $U$8 hybrid-driver calls per trial (Zhang, 14 May 2026).

QCov adapts the classical coverage-guided fuzzing pattern to QNNs. Given an initial seed set $U$9, a trained QNN, and one of $U(\theta,\phi,\lambda)$0, it repeatedly pops a seed, mutates it, and either stores the mutant if it is misclassified or re-enqueues it if it strictly increases the chosen coverage metric (Shao et al., 2024). The essential rule is that only mutants that induce a failure or increase coverage are retained. In this respect, QCov is structurally close to classical CGF, but its coverage oracle is quantum-state based rather than control-flow based (Shao et al., 2024).

Across these frameworks, one can distinguish at least four workflow families: branch-targeted search, novelty-guided state exploration, failure-guided local fuzzing, and coverage-guided seed re-enqueueing. That taxonomy is an interpretive synthesis of the reported methods rather than a term used in the papers.

5. Empirical findings and observed efficacy

The reported empirical results support the claim that guidance improves over uninformed or random baselines, but the type of improvement depends on the setting and metric.

QuanFuzz was evaluated on the seven built-in examples $U(\theta,\phi,\lambda)$1 shipped with the Q♢SI platform, with $U(\theta,\phi,\lambda)$2 qubits, and compared against a random-matrix generator that applies uniformly random single-qubit gates for the same wall-clock time (Wang et al., 2018). Each run was repeated 5 times and averaged. Across the suite, QuanFuzz increased the probability of triggering sensitive branches—and thus line or branch coverage—by roughly 20%–60% over random (Wang et al., 2018).

NovaQ reports results on 1,500 test cases per method for “10×10×10 Grid Coverage Rates” on initial circuits with 3, 5, 7, 10, and 12 qubits (Jin et al., 5 Sep 2025). The reported baseline and NovaQ coverages are 63.4% versus 70.1% for 3 qubits, 57.4% versus 64.9% for 5 qubits, 43.4% versus 60.5% for 7 qubits, 19.2% versus 29.9% for 10 qubits, and 9.5% versus 19.7% for 12 qubits, corresponding to improvements of +10.57%, +13.07%, +39.40%, +55.73%, and +107.37%, respectively (Jin et al., 5 Sep 2025). On the same 1,500 tests, the reported fault detection accuracies are higher for NovaQ than baseline on all listed programs: for example, Grover-05 rises from 83.9% to 93.7%, PE-05 from 83.4% to 92.5%, and QFT-05 from 85.1% to 89.4% (Jin et al., 5 Sep 2025). The paper states that phase diversity is a key driver and that NovaQ spreads test cases more uniformly in the phase dimension (Jin et al., 5 Sep 2025).

In the hybrid setting, five budgeted strategies are compared under a total budget $U(\theta,\phi,\lambda)$3 hybrid-driver calls per trial, repeated over $U(\theta,\phi,\lambda)$4 independent trials: RH, ENUM, RAND-FUZZ, ENUM-FUZZ, and SYM-FUZZ (Zhang, 14 May 2026). On 2-qubit VQE, the mean crash counts are 200.9 $U(\theta,\phi,\lambda)$5 17.8 for RH, 494.6 $U(\theta,\phi,\lambda)$6 9.6 for ENUM, 1387.3 $U(\theta,\phi,\lambda)$7 223.7 for ENUM-FUZZ, 1430.5 $U(\theta,\phi,\lambda)$8 86.9 for RAND-FUZZ, and 1513.8 $U(\theta,\phi,\lambda)$9 66.3 for SYM-FUZZ (Zhang, 14 May 2026). On 4-qubit QAOA MaxCut, the mean crash counts are 305.9 $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$0 13.5 for RH, 301.8 $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$1 13.1 for ENUM, 721.4 $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$2 329.5 for ENUM-FUZZ, 861.7 $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$3 119.5 for RAND-FUZZ, and 773.6 $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$4 427.6 for SYM-FUZZ (Zhang, 14 May 2026). The reported interpretation is that local fuzzing around crash seeds is the primary driver of improvement under a fixed budget, while the value of concolic seed discovery is workload-dependent (Zhang, 14 May 2026).

QCov reports several kinds of empirical evidence on benchmark datasets and QNN models (Shao et al., 2024). Coverage increases monotonically with suite diversity; adding adversarial or random-noise inputs boosts KSC by 30%–50%, SCC by similar amounts, TSC by about 40%, and KEC by about 50%; and coverage-guided fuzzing achieves a test success rate for misclassification of approximately 40%–45%, compared with a random testing baseline of about 20% (Shao et al., 2024). Among the criteria, KSC and SCC yield the highest reported test success rates, up to about 62%, whereas TSC and KEC are more conservative because they require uncovering rarer behaviors (Shao et al., 2024).

A consistent pattern therefore appears across very different targets: guided fuzzing improves either coverage, branch-trigger probability, crash discovery, or bug detection relative to random or unguided testing. A more cautious reading is also warranted: the notion of “improvement” is framework-specific, and direct quantitative comparison across papers is not meaningful because the objectives, workloads, and metrics are different.

6. Limitations, misconceptions, and future directions

Several limitations recur across the literature. The most common is scalability under classical simulation. QuanFuzz notes that time cost grows exponentially in $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$5 due to classical simulation of $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$6 unitaries (Wang et al., 2018). NovaQ states that, as $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$7 grows, state-vector simulation and entropy computations become costly, with memory and time scaling like $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$8, and also notes that the 3D grid grows as $$s = \bigl(\mu_\theta,\sigma^2_\theta,\;\mu_\phi,\sigma^2_\phi,\;\mu_\lambda,\sigma^2_\lambda\bigr)$$9, which may require hierarchical or adaptive discretization at higher qubit counts (Jin et al., 5 Sep 2025). QCov similarly emphasizes that every coverage computation requires repeated circuit execution and estimation of probabilities or entanglement measures, although it reports per-sample coverage times such as 0.10–0.19 s for KSC on MNIST binary tasks and 0.14–0.28 s for KEC, with HCQC variants costing 0.05–0.11 s per sample (Shao et al., 2024). The hybrid work restricts its case studies to small systems, namely 2-qubit VQE and 4-qubit QAOA, and notes that real hardware noise and larger ansätze may alter failure landscapes (Zhang, 14 May 2026).

A second recurring issue is that stronger testing signals do not automatically imply broader semantic assurance. QCov explicitly states that the link between higher coverage and true robustness is suggestive but not theoretically guaranteed (Shao et al., 2024). The hybrid fuzzing study notes that crash counts do not equate to distinct root causes and calls for clustering or injected-fault benchmarks for failure diversity (Zhang, 14 May 2026). These statements address a common misconception: that a higher numerical coverage or crash rate is itself a complete correctness guarantee. The papers do not make that claim.

A third point of methodological caution concerns guidance quality. In the hybrid case, concolic seed discovery helps on VQE but is less stable on QAOA, and SYM-FUZZ shows high variance on the more fragmented QAOA landscape (Zhang, 14 May 2026). NovaQ observes that tuning the seed-pool size $\theta,\phi,\lambda$0, circuits per seed $\theta,\phi,\lambda$1, and survivor count $\theta,\phi,\lambda$2 is nontrivial (Jin et al., 5 Sep 2025). QCov reports that hyperparameters such as $\theta,\phi,\lambda$3, interval sizes, and the range for the entanglement change ratio were chosen by trial and error (Shao et al., 2024). This suggests that guidance in quantum fuzzing is itself a design problem and not merely an implementation detail.

The future directions identified in the papers are correspondingly diverse. NovaQ proposes applying its mutation and selection framework to other generators, combining it with coverage-guided backends such as gate-branch coverage, and evaluating on larger real-world quantum programs such as variational quantum eigensolvers and quantum machine-learning circuits (Jin et al., 5 Sep 2025). QuanFuzz suggests replacing its simple genetic-style search with methods such as MCMC, CMA-ES, or reinforcement learning, guided by the same fitness $\theta,\phi,\lambda$4 (Wang et al., 2018). The hybrid fuzzing work recommends richer symbolic reasoning, scaling to noisy simulators and hardware, developing coverage metrics for HQC, and designing seed-selection policies that balance severity and diversity (Zhang, 14 May 2026). QCov points to hardware-aware coverage metrics, extending mutation operators to full quantum circuits, and theoretical analysis of coverage-robustness trade-offs (Shao et al., 2024).

In aggregate, quantum fuzzing has developed from branch-oriented greybox testing into a broader family of quantum-specific testing methodologies. Its defining feature is not any single mutation operator or coverage metric, but the use of feedback from quantum execution—measurement statistics, internal state metrics, entanglement behavior, or failure information—to steer automated test generation toward under-explored or failure-prone regions of the program’s behavior space.