This is the Replicated Computational Results (RCR) Report for the paper C2|Q⟩: A Robust Framework for Bridging Classical and Quantum Software Development . The paper introduces a modular, hardware-agnostic framework that translates classical problem specifications—Python code or structured JSON—into executable quantum programs across ten problem families and multiple hardware backends. We release the framework source code on GitHub at https://github.com/C2-Q/C2Q , a pretrained parser model on Zenodo at https://zenodo.org/records/19061125 , evaluation data in a separate Zenodo record at https://zenodo.org/records/17071667 , and a PyPI package at https://pypi.org/project/c2q-framework/ for lightweight CLI and API use. Experiment 1 is supported through a released pretrained model and training notebook, while Experiments 2 and 3 are directly executable via documented make targets. This report describes the artifact structure, setup instructions, and the mapping from each execution route to the corresponding experiment.
This is the Replicated Computational Results (RCR) Report for the paper C2|Q⟩: A Robust Framework for Bridging Classical and Quantum Software Development . The paper introduces a modular, hardware-agnostic framework that translates classical problem specifications—Python code or structured JSON—into executable quantum programs across ten problem families and multiple hardware backends. We release the framework source code on GitHub at https://github.com/C2-Q/C2Q , a pretrained parser model on Zenodo at https://zenodo.org/records/19061125 , evaluation data in a separate Zenodo record at https://zenodo.org/records/17071667 , and a PyPI package at https://pypi.org/project/c2q-framework/ for lightweight CLI and API use. Experiment 1 is supported through a released pretrained model and training notebook, while Experiments 2 and 3 are directly executable via documented make targets. This report describes the artifact structure, setup instructions, and the mapping from each execution route to the corresponding experiment.
Quantum Software Engineering (QSE) is emerging as a critical discipline to make quantum computing accessible to a broader developer community; however, most quantum development environments still require developers to engage with low-level details across the software stack—including problem encoding, circuit construction, algorithm configuration, hardware selection, and result interpretation—making them difficult for classical software engineers to use. To bridge this gap, we present C2 ∣Q⟩ , a hardware-agnostic quantum software development framework that translates specific types of classical specifications into quantum-executable programs while preserving methodological rigor. The framework applies modular software engineering principles by classifying the workflow into three core modules: an encoder that classifies problems, produces Quantum-Compatible Formats (QCFs), and constructs quantum circuits, a deployment module that generates circuits and recommends hardware based on fidelity, runtime, and cost, and a decoder that interprets quantum outputs into classical solutions. This architecture supports systematic evaluation across simulators and Noisy Intermediate-Scale Quantum (NISQ) quantum devices, remaining scalable to new problem classes and algorithms. In evaluation, the encoder module achieved a 93.8% completion rate, the hardware recommendation module consistently selected the appropriate quantum devices for workloads scaling up to 56 qubits. End-to-end experiments on 434 Python programs and 100 JSON problem instances demonstrate that the full C2 ∣Q⟩ workflow executes reliably on simulators and can be deployed successfully on representative real quantum hardware, with empirical runs limited to small- and medium-sized instances consistent with current NISQ capabilities. A proxy-based usability analysis further indicates substantial reductions in handwritten lines of code and explicit configuration steps compared to conventional quantum SDK workflows. These results indicate that C2 ∣Q⟩ lowers the entry barrier to quantum software development by providing a reproducible, extensible toolchain that connects classical specifications to quantum execution. The open-source implementation of C2 ∣Q⟩ is available at https://github.com/C2-Q/C2Q and as a ready-to-use Python package at https://pypi.org/project/c2q-framework/ .
Large language models (LLMs) have increasingly been applied to automatic programming code generation. This task can be viewed as a language generation task that bridges natural language, human knowledge, and programming logic. However, it remains underexplored in domains that require interaction with hardware devices, such as quantum programming, where human coders write Python code that is executed on a quantum computer. To address this gap, we introduce QCoder Benchmark, an evaluation framework that assesses LLMs on quantum programming with feedback from simulated hardware devices. Our benchmark offers two key features. First, it supports evaluation using a quantum simulator environment beyond conventional Python execution, allowing feedback of domain-specific metrics such as circuit depth, execution time, and error classification, which can be used to guide better generation. Second, it incorporates human-written code submissions collected from real programming contests, enabling both quantitative comparisons and qualitative analyses of LLM outputs against human-written codes. Our experiments reveal that even advanced models like GPT-4o achieve only around 18.97% accuracy, highlighting the difficulty of the benchmark. In contrast, reasoning-based models such as o3 reach up to 78% accuracy, outperforming averaged success rates of human-written codes (39.98%). We release the QCoder Benchmark dataset and public evaluation API to support further research. (Codes and datasets are available at https://qcoder-bench.github.io/ )
As the capabilities of quantum computing hardware continue to rise, algorithms that exploit them are becoming increasingly complex. These developments increase the need for sophisticated compilation frameworks that translate high-level algorithms into executable code. In the past, most solutions were built with a quantum-first approach and handled mostly pure quantum programs without classical elements such as structured control flow. However, developments in quantum algorithms, error correction, and optimization, as well as the integration into high-performance computing (HPC) environments, depend on such classical elements. As quantum-first approaches increasingly struggle to handle these concepts, classical-first approaches are becoming a promising alternative. In this work, we present the MQT Compiler Collection, a blueprint for a future-proof quantum-classical compilation framework built on the Multi-Level Intermediate Representation (MLIR). After years of experience with the quantum-first approach and its shortcomings, we propose a framework that embraces core MLIR concepts to support the full compilation pipeline from high-level algorithms to hardware-specific instructions. The proposed architecture is designed from the ground up to support complex optimizations beyond, e.g., simple gate cancellation. It is publicly available at https://github.com/munich-quantum-toolkit/core.
This paper presents C2|Q>, a quantum software framework designed to bridge the gap between classical and quantum programming, specifically aimed at traditional developers who lack quantum computing expertise but want to leverage the potential benefits of quantum computers. C2|Q> transforms classical code written in high-level languages into quantum representations, enabling execution on Noisy Intermediate-Scale Quantum (NISQ) computers or simulators, and provides a user-friendly interface. The framework focuses on problems where quantum computing offers advantages, particularly nondeterministic polynomial-time complete (NP-complete) problems, which are considered classically hard.
This paper presents the experimental validation and execution of the EIEZ Language (Version 3) on real physical quantum hardware. Deployed across IBM Quantum processors (ibm_fez, ibm_marrakesh, and ibm_torino, featuring 133 to 156 physical qubits), the EIEZ v3 framework introduces hybrid compilation targeting OpenQASM 2.0 and OpenQASM 3.0, adaptive classical control flow (while, repeat-until with rich CondExpr logic), and hardware topology validation (EIEZTopologyError). The test series evaluated 2- and 3-qubit entanglement circuits (Bell State, GHZ State), quantum algorithms (Deutsch), and depth-scaling tests (H×1 to H×10), executed with up to 4,096 shots per job. Key Results: Full Compilation Compatibility: Seamless execution flow from EIEZ source code to OpenQASM and IBM Quantum hardware. High Entanglement Fidelity: Average fidelity of ~95% across Bell State, GHZ, and Deutsch algorithm executions on physical QPUs. Critical Decoherence Point: Empirical observation of quantum interference breakdown at depth H×3 (~50% deviation from the ideal EIEZ simulator), providing physical evidence of criticality and confirming the applicability of the EIE/ZIE adaptive control framework (Patent BR 10 2025 024459 4). Transpiler Depth Recovery: Fidelity restoration to ~99.7% at depth H×10 driven by internal sequence optimization in Qiskit transpilation. Open FAIR Dataset: Release of machine-readable raw measurement counts (JSON/CSV), UTC timestamps, and IBM Job IDs for open verification. Links & Resources: IBM Quantum Cloud Platform: https://quantum.cloud.ibm.com/ Raw Execution Counts (JSON / CSV): https://github.com/joemerson/eiez-lang/blob/main/eiez-lang/Teste_rodados_IBM_/JSON.json Local Simulation Notebooks (Zenodo): https://doi.org/10.5281/zenodo.19078764 EIEZ Compiler Source Code (GitHub): https://github.com/joemerson/eiez-lang Complete EIE/ZIE Theory & Framework (Zenodo): https://doi.org/10.5281/zenodo.19005280 Zenodo DOI: https://doi.org/10.5281/zenodo.19078829
This software-framework note archives scpn-quantum-control, a reproducible Kuramoto--XY quantum-control workflow combining Python/Qiskit orchestration, Rust acceleration, hardware artefact packaging, and publication-grade analysis surfaces. The software supports construction of heterogeneous oscillator networks, XY-Hamiltonian mapping, topology-informed ansatz generation, simulator and hardware execution, and reproducible post-processing of IBM artefacts. The record documents the framework as a research software artefact rather than a standalone physics claim. It highlights the repository structure, reproducibility workflow, accelerated kernels, benchmark and parity checks, and the relationship between source code, generated artefacts, and paper records. The archive includes the JOSS-style manuscript source, bibliography, preview TeX, and rebuilt PDF. Repository field and DOI metadata link the software note back to https://github.com/anulum/scpn-quantum-control.