Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

Concolic-Guided Fuzzing of Hybrid Quantum–Classical Programs

Anonymous Author(s)

Published Feb 21, 2026• 0 citations
Publisher

Abstract

# Concolic-based Fuzzing for Hybrid Quantum–Classical Programs This repository contains a **prototype** for *concolic-guided fuzzing* of hybrid quantum–classical programs, instantiated on two canonical NISQ workloads implemented in Qiskit: - **VQE case study** – small molecular Hamiltonian (H₂-like) - **QAOA case study** – small MaxCut instance The core idea is to treat a **hybrid input** as (`c`, `θ`) where - `c` = classical hyperparameters (optimizer type, max iterations, learning rate) - `θ` = quantum circuit parameters (angles for VQE/QAOA ansätze), and to compare three testing strategies under a **fixed execution budget**: 1. **Random Hybrid (RH)** – sample `(c, θ)` i.i.d. from global distributions. 2. **Concolic+Fuzz (CF-ENUM)** – enumerative “concolic” exploration over classical configs, then local fuzzing on `θ`. 3. **Concolic+Fuzz (CF-SYM)** – lightweight SMT-based exploration over classical configs, then local fuzzing on `θ`. All strategies share the same: - non-convergence oracle (per case study), - shot configuration, - and total number of hybrid driver calls per trial (e.g., 2,000). ## 1. Environment and Dependencies Tested with: - **Python**: 3.10 - **Qiskit** (Terra + Aer) - **NumPy** - **Matplotlib** - **z3-solver** (for the symbolic concolic layer) Example setup with Conda: ```bash conda create -n qiskit python=3.10 conda activate qiskit pip install qiskit qiskit-aer numpy matplotlib z3-solver ``` ## 2. Running the VQE Case Study Smoke Test with single VQE run + random baseline ```bash python vqe_driver.py python input_space.py python concolic_runner.py ``` To reproduce the main VQE results (e.g., with budget = 2000, 20 trials): ```bash python budgeted_experiments.py ``` This will run multiple trials with the three strategies, and the results go to `vqe_results_budget2000.csv`. ## 3. Running the QAOA Case Study Smoke Test: ```bash python qaoa_smoke_test.py ``` Concolic demo: ```bash python qaoa_concolic_engine.py python qaoa_concolic_runner.py ``` Reproduce the results: ```bash python qaoa_budgeted_experiments.py ``` The results go to: `qaoa_results_budget2000.csv`. ## License & Citation This project is released under the **MIT License**. See the `LICENSE` file for the full text. If you use this code in academic or scientific work, we kindly ask you to cite our project. ## Acknowledgments Parts of the design and implementation of this prototype were developed with assistance from OpenAI's ChatGPT. The system was used to help brainstorm the architecture, draft and refine Python code snippets. All code and experiments in this repository were executed, inspected, and validated by the author(s). Any errors or omissions remain the responsibility of the author(s).

DOI
10.5281/zenodo.18719832

Related papers

Failure-Guided Fuzzing for Hybrid Quantum-Classical Programs

Lei Zhang (38117)

Hybrid quantum-classical (HQC) algorithms, such as the Variational Quantum Eigensolver (VQE) and the Quantum Approximate Optimization Algorithm (QAOA), are central to near-term quantum computing but remain challenging to test. Sampling-based fuzzing can expose faulty or non-convergent configurations, but under realistic execution budgets, it may miss failure-prone regions in the joint space of classical optimizer settings and quantum circuit parameters. This paper studies failure-guided fuzzing for HQC programs. It models a hybrid input as a pair of classical optimizer hyperparameters and quantum circuit parameters, and evaluates a two-phase strategy that first searches for non-convergent seeds and then locally fuzzes circuit parameters around those seeds. To understand where the gains come from, five budgeted strategies are compared: random hybrid testing, classical enumeration without fuzzing, random-seed local fuzzing, enumeration-seed local fuzzing, and concolic-seed local fuzzing. The study is implemented on a VQE instance and a QAOA MaxCut instance in Qiskit. The results show that failure-guided local fuzzing is the main driver of improvement over random testing, while concolic seed discovery provides additional benefits on VQE but is less stable on QAOA. These findings suggest that reusing failure information is a promising direction for HQC testing, but that the value of concolic seed discovery is workload-dependent.

•May 14, 2026•0 citations

Failure-Guided Fuzzing for Hybrid Quantum-Classical Programs

Lei Zhang

Hybrid quantum-classical (HQC) algorithms, such as the Variational Quantum Eigensolver (VQE) and the Quantum Approximate Optimization Algorithm (QAOA), are central to near-term quantum computing but remain challenging to test. Sampling-based fuzzing can expose faulty or non-convergent configurations, but under realistic execution budgets, it may miss failure-prone regions in the joint space of classical optimizer settings and quantum circuit parameters. This paper studies failure-guided fuzzing for HQC programs. It models a hybrid input as a pair of classical optimizer hyperparameters and quantum circuit parameters, and evaluates a two-phase strategy that first searches for non-convergent seeds and then locally fuzzes circuit parameters around those seeds. To understand where the gains come from, five budgeted strategies are compared: random hybrid testing, classical enumeration without fuzzing, random-seed local fuzzing, enumeration-seed local fuzzing, and concolic-seed local fuzzing. The study is implemented on a VQE instance and a QAOA MaxCut instance in Qiskit. The results show that failure-guided local fuzzing is the main driver of improvement over random testing, while concolic seed discovery provides additional benefits on VQE but is less stable on QAOA. These findings suggest that reusing failure information is a promising direction for HQC testing, but that the value of concolic seed discovery is workload-dependent.

cs.SECross-listedarXiv:2605.14219•May 15, 2026•0 citations

KQFuzz: Knowledge-Guided Fuzzing for Quantum Libraries via Large Language Models

Fuyuan Xia, Qixin Zhang, Chenhao Ying +5 more

As quantum computing continually improves, ensuring the reliability and correctness of quantum libraries has become increasingly critical. To this end, many LLM-based fuzzing approaches towards quantum libraries have been proposed to uncover potential bugs. However, these methods still suffer from limitations such as insufficient flexibility and low efficiency, which hinder the progress of the quantum computing field. To address these challenges, we propose KQFuzz, a novel knowledge-guided fuzzer for quantum libraries. It leverages comprehensive codebase knowledge to ground LLM-based test generation, synergizing this with fitness-guided evaluation and two-level mutations to explore complex execution paths and trigger potential bugs. Firstly, KQFuzz introduces a novel prompting scheme tailored to quantum programs, which strategically incorporates knowledge of the codebase to efficiently generate high-quality quantum seed programs. Moreover, we develop evaluation and mutation strategies to handle the generated seed programs, facilitating efficient fuzzing execution while further enriching the diversity of the resulting test cases. We implement KQFuzz and conduct fuzzing on three popular quantum libraries, including Qiskit, PennyLane, and Cirq. Experimental results demonstrate that our approach significantly outperforms other state-of-the-art methods, with coverage improved by up to 18.44%. During the development of KQFuzz, we discovered 13 bugs, all of which have been confirmed and 12 have already been fixed by the developers.

cs.SECross-listedarXiv:2607.25647•IEEE/ACM International Conference on Automated Software Engineering (ASE)•Jul 29, 2026•2 citations

Towards near-term quantum simulation of materials

Laura Clinton, Toby S. Cubitt, Brian Flynn +6 more

Overview of data provided in support of Towards near-term quantum simulation of materials Contents of this folder: `analyse_materials_results.py`: script used to generate the summary tables and figures presented in the manuscript. `towards_quantum_simulation_data`: raw data used and produced when studying various 3D materials. `towards_quantum_simulation_analysis`: tables (in `.tex` format) and figures (as PDFs) presented in the manuscript. The contents of `towards_quantum_simulation_analysis` were generated by `analyse_materials_results.py`, i.e. the user need not run the script to produce the output files. Users can generate these analyses directly by running ```python analyse_materials_results.py```, though note the following packages will first need to be installed: `pandas >= 1.2.3` `numpy >= 1.23` `seaborn >= 0.11.1` `lfig >= 0.1.3` `matplotlib > 3.7.0` Included data Within `towards_quantum_simulation_data`, there are subfolders for each of the materials described in the manuscript, i.e. `SrVO3`, `GaAs`, `H3S`, `Si`, `Li2CuO2`. Within each material's folder are further subfolders for the `hamiltonian` and `encoding` used to represent the material, as well as subfolders for each of the `algorithms` studied. `hamiltonian`: files which specify the Hamiltonian for the material under study. There are a number of files `interactions.json` Hamiltonian terms in terms of Majorana monomials. `map_majorana_to_mode.json` keys are Majorana indices; values are the mode index to which they are associated. `map_mode_to_group.json` keys are mode indices; values are the group (or site) index to which they are associated. `map_group_to_position.json` keys are group indices; values are the corresponding 3D Cartesian coordinates of the lattice used to represent the material. `stage_data.json` contains key/value pairs of any other fields of interest. `encoding` files which specify the fermionic encoding which is customised for the material under study. `encoding.json` which details the edges of the hybrid compact encoding described in Section VI of the supplementary material. `precompiler.json` contains all the information which permits the encoding construction, including the Hamiltonian terms (`_interactions`) which match those in `hamiltonian/interactions.json`. The same mappings as present in the Hamiltonian data(a.g. `map_group_to_position`). `stage_data.json` contains key/value pairs of any other fields of interest. `algorithms` contains subfolders for each of the algorithms desribed in the manuscript Those explored for circuits depths: `TDSSplitTermsPriorityCircuitDepth` (TDS in the manuscript) `TDSSplitTermsPriorityCircuitDepthNoSwapNetwork` (TDS\*) `VQESplitTerms` (VQE) `VQESplitTermsNoSwapNetwork` (VQE*) each of which contain the files, inside the `circuitry` folder: `circuit_terms.csv`, which lists each individual term, together with their Pauli string and rotation angle, required to construct the corresponding quantum circuit `circuit_layers_to_implement.csv` groups the same terms into layers to achieve parallelism in the circuit. `stage_data.json` contains key/value pairs of any other fields of interest. and those used to compose measurement layers, as outlined in Section VII D of the supplementary material: `MeasurementCommutativity` `MeasurementNaiveQubitwise` `MeasurementNonCrossing` each of which contain the files, inside the `compilation` folder: `layers.csv` lists the terms which may be measured simultaneously to achieve the measurement strategies shown in Table S14. `stage_data.json` contains key/value pairs of any other fields of interest. CSV files In `towards_quantum_simulation_data`, there are unified CSV files containing the results of applying the procedures described in the manuscript to the target materials. `circuit_costs.csv`: results of running the circuit compiler described in the manuscript. `measurements.csv`: results of running the measurement compiler described in the manuscript. These CSVs are used in the analysis script `analyse_materials_results.py` to produce the figures and tables presented in the manuscript.

arXiv:2205.15256•May 30, 2022•16 citations

From Ising to Potts: Physics-inspired Potts machines of coupled oscillators for low-energy sampling and combinatorial optimization

Yi Cheng, Zongli Lin

Repository containing the code to reproduce the experiments in the paper "From Ising to Potts: physics-inspired Potts machines in coupled oscillators for low-energy sampling and combinatorial optimization". It contains four standalone Python scripts: Max_2_cut.py — OPM solver for Max-2-Cut Max_3_cut.py — OPM solver for Max-3-Cut Max_4_cut.py — OPM solver for Max-4-Cut Max_5_cut.py — OPM solver for Max-5-Cut The benchmark graph instances G1–G5 are included as text files (G1.txt–G5.txt) in the same folder. Requirements Python 3.9+ and the packages listed in requirements.txt (notably: numpy, scipy, matplotlib, torch, torchsde). How to run (Jupyter / terminal) After installing dependencies: In a Jupyter notebook: %run Max_2_cut.py %run Max_3_cut.py %run Max_4_cut.py %run Max_5_cut.py Or in a terminal: python Max_2_cut.py (and similarly for Max-3/4/5) The scripts generate the output figures in the working directory (e.g., box plots summarizing solution quality across instances). GPU recommendation For best performance, we recommend running the code on a GPU. The runtime numbers reported below were measured on NVIDIA GeForce RTX 2080 Ti (CUDA 12.8; driver 570.124.06). Actual wall-clock time may vary with hardware and system load. Reproducibility and runtime For a faster sanity check, start with seed_num = 1 (typical wall-clock times to finish all instances G1–G5: Max-3-Cut ~12 min, Max-4-Cut ~16 min, Max-5-Cut ~24 min).To reproduce the results reported in the paper, use seed_num = 20.

arXiv:2507.18379•Jul 23, 2025•6 citations

Noise-Mitigated Quantum-Classical Hybrid Classification via Zero-Noise Extrapolation

Alexandru-Florin Boboc

Performance Optimization of Noise-Mitigated Quantum-Classical Hybrid Classifiers via Zero-Noise Extrapolation in NISQ Environments Overview Near-Term Intermediate-Scale Quantum (NISQ) hardware remains heavily constrained by physical noise, gate infidelities, and decoherence, which severely degrade the performance of Variational Quantum Classifiers (VQCs). This research presents an end-to-end, noise-mitigated hybrid quantum-classical machine learning pipeline that integrates PyTorch classical layers with PennyLane parameterized quantum circuits (PQCs) and applies Zero-Noise Extrapolation (ZNE) via Mitiq to counteract hardware noise. Key Highlights & Contributions Modular Hybrid Architecture: Combines classical feature mapping and post-processing in PyTorch with parameterized quantum variational circuits built in PennyLane. Digital Error Mitigation: Evaluates global gate folding ($G \to G G^\dagger G$) across varying scale factors ($\lambda \in \{1, 3, 5\}$) to extrapolate expectation values back to the zero-noise limit. Accuracy Recovery: Demonstrates that ZNE recovers classification accuracy near ideal noiseless performance ($98.5\%$) under low-to-moderate depolarizing noise levels (p < 0.01), outperforming unmitigated noisy executions by up to 11.3%. Model Benchmarking: Directly compares linear and second-order polynomial extrapolation models, analyzing variance trade-offs under finite shot noise constraints. Repository & Code Contents This deposit includes the full PDF manuscript alongside the accompanying code archive: Noise_Mitigated_Quantum_Classical_Hybrid_Classifier_with_Zero_Noise_Extrapolation.pdf — Full IEEE-formatted research paper. Noise-MitigatedQuantum-ClassicalHybridClassifierwithZero-NoiseExtrapolation.ipynb — Executable Jupyter Notebook containing the full PyTorch–PennyLane–Mitiq benchmarking pipeline. requirements.txt & README — Environment setup and reproduction instructions. How to Cite If you find this work or codebase helpful for your research in Quantum Machine Learning (QML) or Quantum Error Mitigation (QEM), please cite this preprint using the Zenodo DOI provided above.

•Aug 10, 2026•0 citations

Concolic-based Fuzzing for Hybrid Quantum–Classical Programs This repository contains a prototype for concolic-guided fuzzing of hybrid quantum–classical programs, instantiated on two canonical NISQ workloads implemented in Qiskit: - VQE case study – small molecular Hamiltonian (H₂-like) - QAOA case study – small MaxCut instance The core idea is to treat a hybrid input as (c, θ) where - c = classical hyperparameters (optimizer type, max iterations, learning rate) - θ = quantum circuit parameters (angles for VQE/QAOA ansätze), and to compare three testing strategies under a fixed execution budget: 1. Random Hybrid (RH) – sample (c, θ) i.i.d. from global distributions. 2. Concolic+Fuzz (CF-ENUM) – enumerative “concolic” exploration over classical configs, then local fuzzing on θ. 3. Concolic+Fuzz (CF-SYM) – lightweight SMT-based exploration over classical configs, then local fuzzing on θ. All strategies share the same: - non-convergence oracle (per case study), - shot configuration, - and total number of hybrid driver calls per trial (e.g., 2,000). ## 1. Environment and Dependencies Tested with: - Python: 3.10 - Qiskit (Terra + Aer) - NumPy - Matplotlib - z3-solver (for the symbolic concolic layer) Example setup with Conda: bash conda create -n qiskit python=3.10 conda activate qiskit pip install qiskit qiskit-aer numpy matplotlib z3-solver ## 2. Running the VQE Case Study Smoke Test with single VQE run + random baseline bash python vqe_driver.py python input_space.py python concolic_runner.py To reproduce the main VQE results (e.g., with budget = 2000, 20 trials): bash python budgeted_experiments.py This will run multiple trials with the three strategies, and the results go to vqe_results_budget2000.csv. ## 3. Running the QAOA Case Study Smoke Test: bash python qaoa_smoke_test.py Concolic demo: bash python qaoa_concolic_engine.py python qaoa_concolic_runner.py Reproduce the results: bash python qaoa_budgeted_experiments.py The results go to: qaoa_results_budget2000.csv. ## License & Citation This project is released under the MIT License. See the LICENSE file for the full text. If you use this code in academic or scientific work, we kindly ask you to cite our project. ## Acknowledgments Parts of the design and implementation of this prototype were developed with assistance from OpenAI's ChatGPT. The system was used to help brainstorm the architecture, draft and refine Python code snippets. All code and experiments in this repository were executed, inspected, and validated by the author(s). Any errors or omissions remain the responsibility of the author(s).

Hybrid quantum-classical (HQC) algorithms, such as the Variational Quantum Eigensolver (VQE) and the Quantum Approximate Optimization Algorithm (QAOA), are central to near-term quantum computing but remain challenging to test. Sampling-based fuzzing can expose faulty or non-convergent configurations, but under realistic execution budgets, it may miss failure-prone regions in the joint space of classical optimizer settings and quantum circuit parameters. This paper studies failure-guided fuzzing for HQC programs. It models a hybrid input as a pair of classical optimizer hyperparameters and quantum circuit parameters, and evaluates a two-phase strategy that first searches for non-convergent seeds and then locally fuzzes circuit parameters around those seeds. To understand where the gains come from, five budgeted strategies are compared: random hybrid testing, classical enumeration without fuzzing, random-seed local fuzzing, enumeration-seed local fuzzing, and concolic-seed local fuzzing. The study is implemented on a VQE instance and a QAOA MaxCut instance in Qiskit. The results show that failure-guided local fuzzing is the main driver of improvement over random testing, while concolic seed discovery provides additional benefits on VQE but is less stable on QAOA. These findings suggest that reusing failure information is a promising direction for HQC testing, but that the value of concolic seed discovery is workload-dependent.
Hybrid quantum-classical (HQC) algorithms, such as the Variational Quantum Eigensolver (VQE) and the Quantum Approximate Optimization Algorithm (QAOA), are central to near-term quantum computing but remain challenging to test. Sampling-based fuzzing can expose faulty or non-convergent configurations, but under realistic execution budgets, it may miss failure-prone regions in the joint space of classical optimizer settings and quantum circuit parameters. This paper studies failure-guided fuzzing for HQC programs. It models a hybrid input as a pair of classical optimizer hyperparameters and quantum circuit parameters, and evaluates a two-phase strategy that first searches for non-convergent seeds and then locally fuzzes circuit parameters around those seeds. To understand where the gains come from, five budgeted strategies are compared: random hybrid testing, classical enumeration without fuzzing, random-seed local fuzzing, enumeration-seed local fuzzing, and concolic-seed local fuzzing. The study is implemented on a VQE instance and a QAOA MaxCut instance in Qiskit. The results show that failure-guided local fuzzing is the main driver of improvement over random testing, while concolic seed discovery provides additional benefits on VQE but is less stable on QAOA. These findings suggest that reusing failure information is a promising direction for HQC testing, but that the value of concolic seed discovery is workload-dependent.
As quantum computing continually improves, ensuring the reliability and correctness of quantum libraries has become increasingly critical. To this end, many LLM-based fuzzing approaches towards quantum libraries have been proposed to uncover potential bugs. However, these methods still suffer from limitations such as insufficient flexibility and low efficiency, which hinder the progress of the quantum computing field. To address these challenges, we propose KQFuzz, a novel knowledge-guided fuzzer for quantum libraries. It leverages comprehensive codebase knowledge to ground LLM-based test generation, synergizing this with fitness-guided evaluation and two-level mutations to explore complex execution paths and trigger potential bugs. Firstly, KQFuzz introduces a novel prompting scheme tailored to quantum programs, which strategically incorporates knowledge of the codebase to efficiently generate high-quality quantum seed programs. Moreover, we develop evaluation and mutation strategies to handle the generated seed programs, facilitating efficient fuzzing execution while further enriching the diversity of the resulting test cases. We implement KQFuzz and conduct fuzzing on three popular quantum libraries, including Qiskit, PennyLane, and Cirq. Experimental results demonstrate that our approach significantly outperforms other state-of-the-art methods, with coverage improved by up to 18.44%. During the development of KQFuzz, we discovered 13 bugs, all of which have been confirmed and 12 have already been fixed by the developers.
Overview of data provided in support of Towards near-term quantum simulation of materials Contents of this folder: `analyse_materials_results.py`: script used to generate the summary tables and figures presented in the manuscript. `towards_quantum_simulation_data`: raw data used and produced when studying various 3D materials. `towards_quantum_simulation_analysis`: tables (in `.tex` format) and figures (as PDFs) presented in the manuscript. The contents of `towards_quantum_simulation_analysis` were generated by `analyse_materials_results.py`, i.e. the user need not run the script to produce the output files. Users can generate these analyses directly by running ```python analyse_materials_results.py```, though note the following packages will first need to be installed: `pandas >= 1.2.3` `numpy >= 1.23` `seaborn >= 0.11.1` `lfig >= 0.1.3` `matplotlib > 3.7.0` Included data Within `towards_quantum_simulation_data`, there are subfolders for each of the materials described in the manuscript, i.e. `SrVO3`, `GaAs`, `H3S`, `Si`, `Li2CuO2`. Within each material's folder are further subfolders for the `hamiltonian` and `encoding` used to represent the material, as well as subfolders for each of the `algorithms` studied. `hamiltonian`: files which specify the Hamiltonian for the material under study. There are a number of files `interactions.json` Hamiltonian terms in terms of Majorana monomials. `map_majorana_to_mode.json` keys are Majorana indices; values are the mode index to which they are associated. `map_mode_to_group.json` keys are mode indices; values are the group (or site) index to which they are associated. `map_group_to_position.json` keys are group indices; values are the corresponding 3D Cartesian coordinates of the lattice used to represent the material. `stage_data.json` contains key/value pairs of any other fields of interest. `encoding` files which specify the fermionic encoding which is customised for the material under study. `encoding.json` which details the edges of the hybrid compact encoding described in Section VI of the supplementary material. `precompiler.json` contains all the information which permits the encoding construction, including the Hamiltonian terms (`_interactions`) which match those in `hamiltonian/interactions.json`. The same mappings as present in the Hamiltonian data(a.g. `map_group_to_position`). `stage_data.json` contains key/value pairs of any other fields of interest. `algorithms` contains subfolders for each of the algorithms desribed in the manuscript Those explored for circuits depths: `TDSSplitTermsPriorityCircuitDepth` (TDS in the manuscript) `TDSSplitTermsPriorityCircuitDepthNoSwapNetwork` (TDS\*) `VQESplitTerms` (VQE) `VQESplitTermsNoSwapNetwork` (VQE*) each of which contain the files, inside the `circuitry` folder: `circuit_terms.csv`, which lists each individual term, together with their Pauli string and rotation angle, required to construct the corresponding quantum circuit `circuit_layers_to_implement.csv` groups the same terms into layers to achieve parallelism in the circuit. `stage_data.json` contains key/value pairs of any other fields of interest. and those used to compose measurement layers, as outlined in Section VII D of the supplementary material: `MeasurementCommutativity` `MeasurementNaiveQubitwise` `MeasurementNonCrossing` each of which contain the files, inside the `compilation` folder: `layers.csv` lists the terms which may be measured simultaneously to achieve the measurement strategies shown in Table S14. `stage_data.json` contains key/value pairs of any other fields of interest. CSV files In `towards_quantum_simulation_data`, there are unified CSV files containing the results of applying the procedures described in the manuscript to the target materials. `circuit_costs.csv`: results of running the circuit compiler described in the manuscript. `measurements.csv`: results of running the measurement compiler described in the manuscript. These CSVs are used in the analysis script `analyse_materials_results.py` to produce the figures and tables presented in the manuscript.
Repository containing the code to reproduce the experiments in the paper "From Ising to Potts: physics-inspired Potts machines in coupled oscillators for low-energy sampling and combinatorial optimization". It contains four standalone Python scripts: Max_2_cut.py — OPM solver for Max-2-Cut Max_3_cut.py — OPM solver for Max-3-Cut Max_4_cut.py — OPM solver for Max-4-Cut Max_5_cut.py — OPM solver for Max-5-Cut The benchmark graph instances G1–G5 are included as text files (G1.txt–G5.txt) in the same folder. Requirements Python 3.9+ and the packages listed in requirements.txt (notably: numpy, scipy, matplotlib, torch, torchsde). How to run (Jupyter / terminal) After installing dependencies: In a Jupyter notebook: %run Max_2_cut.py %run Max_3_cut.py %run Max_4_cut.py %run Max_5_cut.py Or in a terminal: python Max_2_cut.py (and similarly for Max-3/4/5) The scripts generate the output figures in the working directory (e.g., box plots summarizing solution quality across instances). GPU recommendation For best performance, we recommend running the code on a GPU. The runtime numbers reported below were measured on NVIDIA GeForce RTX 2080 Ti (CUDA 12.8; driver 570.124.06). Actual wall-clock time may vary with hardware and system load. Reproducibility and runtime For a faster sanity check, start with seed_num = 1 (typical wall-clock times to finish all instances G1–G5: Max-3-Cut ~12 min, Max-4-Cut ~16 min, Max-5-Cut ~24 min).To reproduce the results reported in the paper, use seed_num = 20.
Performance Optimization of Noise-Mitigated Quantum-Classical Hybrid Classifiers via Zero-Noise Extrapolation in NISQ Environments Overview Near-Term Intermediate-Scale Quantum (NISQ) hardware remains heavily constrained by physical noise, gate infidelities, and decoherence, which severely degrade the performance of Variational Quantum Classifiers (VQCs). This research presents an end-to-end, noise-mitigated hybrid quantum-classical machine learning pipeline that integrates PyTorch classical layers with PennyLane parameterized quantum circuits (PQCs) and applies Zero-Noise Extrapolation (ZNE) via Mitiq to counteract hardware noise. Key Highlights & Contributions Modular Hybrid Architecture: Combines classical feature mapping and post-processing in PyTorch with parameterized quantum variational circuits built in PennyLane. Digital Error Mitigation: Evaluates global gate folding (G→GG†GG \to G G^\dagger GG→GG†G) across varying scale factors (λ∈{1,3,5}\lambda \in \{1, 3, 5\}λ∈{1,3,5}) to extrapolate expectation values back to the zero-noise limit. Accuracy Recovery: Demonstrates that ZNE recovers classification accuracy near ideal noiseless performance (98.5%98.5\%98.5%) under low-to-moderate depolarizing noise levels (p < 0.01), outperforming unmitigated noisy executions by up to 11.3%. Model Benchmarking: Directly compares linear and second-order polynomial extrapolation models, analyzing variance trade-offs under finite shot noise constraints. Repository & Code Contents This deposit includes the full PDF manuscript alongside the accompanying code archive: Noise_Mitigated_Quantum_Classical_Hybrid_Classifier_with_Zero_Noise_Extrapolation.pdf — Full IEEE-formatted research paper. Noise-MitigatedQuantum-ClassicalHybridClassifierwithZero-NoiseExtrapolation.ipynb — Executable Jupyter Notebook containing the full PyTorch–PennyLane–Mitiq benchmarking pipeline. requirements.txt & README — Environment setup and reproduction instructions. How to Cite If you find this work or codebase helpful for your research in Quantum Machine Learning (QML) or Quantum Error Mitigation (QEM), please cite this preprint using the Zenodo DOI provided above.