QSMEF — Quantum Software Engineering Module Evaluation Framework (v1.1.0) QSMEF is a computational framework for evaluating the functional contributions of quantum circuit components using cooperative game theory and Shapley values. The implementation provides a modular architecture that separates case-study construction from a general applicability validation procedure. Each case is represented through a common computational specification, including the initial quantum state, functional blocks, execution schedule, Hermitian observable, functional constraints, and executable semantic contract. The framework supports coalition evaluation through identity neutralization of absent functional blocks while preserving the original execution order. It evaluates technical conditions, functional constraints, and declared semantic invariants before determining whether functional attribution is applicable. For applicable configurations, QSMEF computes Shapley values and numerically verifies the efficiency property. The implementation also includes an optional granularity assistant for evaluating alternative functional block groupings. The software includes five computational case studies: SKW quantum walk search, QAOA-MaxCut, TwoLocal-H₂, QPE/Shor, and Minimum Bisection. Semantic validation is limited to the declared executable criteria and does not independently establish complete semantic comparability across coalitions. This release supports the computational implementation and reproducibility of the QSMEF journal article.
QSMEF — Quantum Software Engineering Module Evaluation Framework (v1.1.0) QSMEF is a computational framework for evaluating the functional contributions of quantum circuit components using cooperative game theory and Shapley values. The implementation provides a modular architecture that separates case-study construction from a general applicability validation procedure. Each case is represented through a common computational specification, including the initial quantum state, functional blocks, execution schedule, Hermitian observable, functional constraints, and executable semantic contract. The framework supports coalition evaluation through identity neutralization of absent functional blocks while preserving the original execution order. It evaluates technical conditions, functional constraints, and declared semantic invariants before determining whether functional attribution is applicable. For applicable configurations, QSMEF computes Shapley values and numerically verifies the efficiency property. The implementation also includes an optional granularity assistant for evaluating alternative functional block groupings. The software includes five computational case studies: SKW quantum walk search, QAOA-MaxCut, TwoLocal-H₂, QPE/Shor, and Minimum Bisection. Semantic validation is limited to the declared executable criteria and does not independently establish complete semantic comparability across coalitions. This release supports the computational implementation and reproducibility of the QSMEF journal article.
QSMEF — Computational Implementation and Reproducibility QSMEF (Quantum Software Engineering Module Evaluation Framework) is a framework for evaluating the functional contributions of blocks in quantum circuits using coalition-based observable measurements and Shapley values, subject to explicitly declared technical, functional, and semantic applicability conditions. This archive provides the computational implementation and supporting research artifacts associated with the QSMEF journal manuscript. The package includes five quantum computing case studies: QAOA–MaxCut, TwoLocal–H₂, the SKW quantum walk, QPE–Shor, and graph partitioning (minimum bisection). These cases illustrate the applicability and limitations of functional attribution under different algorithmic configurations and declared semantic constraints. The archive contains Python source code, dependency specifications, automated regression tests, reference results, execution logs, and documentation. It also includes bibliographic records and analysis materials supporting the literature review of 32 selected studies in Quantum Software Engineering. QSMEF distinguishes technical validity, functional constraints, and executable semantic criteria. The framework verifies formalizable conditions across circuit coalitions, while recognizing that satisfying these conditions does not independently establish complete semantic comparability. The regression tests support computational consistency and reproducibility against previously recorded reference results. They do not constitute independent external validation of the framework or its scientific conclusions. This release is intended to support transparency, traceability, reproducibility, and further research on component-level functional evaluation in quantum software engineering.
QSMEF (Quantum Software Engineering Module Evaluation Framework) is a framework for evaluating the functional contributions of components in quantum software. This software release provides a Python validator, documentation, and reproducible results for five quantum software case studies: SKW quantum walk search, QAOA–MaxCut, TwoLocal–H₂, QPE/Shor, and Minimum Bisection. The framework uses a Hermitian observable to define a functional evaluation metric and Shapley values to attribute contributions to individual components. The validator assesses technical validity and applicability under declared functional constraints. The repository includes experimental results, applicability assessments, and a comparison of the original and modified SKW oracle. Source code: https://github.com/QSMEF/QSMEF-Journal-2026 Version: 1.0.0
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/ .
Quantum software development has largely focused on algorithms, with limited attention to software architecture. As computing moves toward hybrid quantum-classical systems, this gap limits scalability, reusability, and engineering rigor. This study introduces a component-based quantum software architecture framework (QSAF) for hybrid quantum-classical software systems, enabling developers to transition from circuit-level design to system-level reasoning. We identified 34 reusable quantum circuit primitives across seven functional categories and reinterpreted them as architectural components with explicit interfaces and design-relevant constraints. These components are further characterized using non-functional dimensions such as circuit depth, error sensitivity, and information flow, enabling a structured analysis of design trade-offs. The proposed QSAF framework establishes a multi-level abstraction hierarchy linking quantum gates, circuit primitives, algorithmic structures, and hybrid system architectures. Through this approach, common workflows, particularly hybrid quantum-classical workflows such as variational quantum algorithms, can be systematically decomposed, compared, and optimized. By making the architectural structure and trade-offs explicit, this study provides a foundation for quantum software engineering, supporting modular design, reuse, and informed architectural decision-making in quantum application development.
Quantum computing promises transformative computational capabilities; however, the absence of structured and standardized software engineering significantly limits its practical scalability. Quantum Software Engineering (QSE) remains fragmented, tool-centric, and largely experimental. This paper proposes a structured Quantum Software Engineering Lifecycle Framework that systematically integrates requirements engineering, hybrid design, quantum development, verification, deployment, and governance. To validate the proposed lifecycle, a two-stage evaluation was conducted. First, a Delphi-based expert validation involving 15 domain experts assessed clarity, feasibility, scalability, and hybrid applicability. Second, a simulation-based comparative analysis using Qiskit and PennyLane evaluated the lifecycle against ad-hoc development workflows across variational and search-based quantum algorithms. Results demonstrate a 24% reduction in development time, 15–18% improvement in execution fidelity, and significant gains in modularity, reusability, and tool interoperability. These findings confirm that adopting a structured lifecycle enables more reliable, scalable, and sustainable quantum software development, positioning QSE as a mature engineering discipline rather than purely experimental practice.
The diversity of quantum hardware platforms creates significant algorithm portability challenges, with each platform employing distinct instruction sets, gate implementations, and physical constraints that hinder software reusability. This paper presents a framework for designing portable quantum assembly languages enabling seamless cross-platform execution. Through systematic profiling of Shor’s, Grover’s, and QAOA algorithms on IBM Qiskit, Microsoft Q#, and Google Cirq — 3,216 executions of identical, reference-validated logical circuits — we identify key portability challenges and derive empirically grounded design criteria from execution-pattern analysis. With matched workloads, cross-platform circuit-depth divergence is 1.3–1.6× where no gate decomposition is required and rises to 94.8× under multi-controlled decomposition pressure, of which 3.36× is genuine same-level synthesis divergence and the remainder an abstraction-level measurement gap; optimization semantics, topology expressibility, and quantum–classical execution contracts diverge analogously. The framework balances hardware abstraction with performance optimization through declared abstraction levels, topology-aware compilation, optimization profiles with defined semantics, and a universal gate set with platform-specific decomposition. Prototype validation demonstrates 100% automated compilation of unmodified single-source programs across 30 platform configurations, with all 90 executions passing calibrated distributional acceptance gates and exact statevector fidelity of 1.000000 against the language’s reference semantics, providing feasibility evidence for vendor-independent quantum software development.