The Gene Is Not the Gate: Conceptualizing the Semantic Genome of Quantum Software

arXiv:2611.13049v1 [cs.SE] 9 Nov 2026

The Gene Is Not the Gate: Conceptualizing the Semantic Genome of Quantum Software Jiongchi Yu

Yue Duan

Ziming Zhao

Nanyang Technological University Singapore, Singapore jiongchiyu@acm.org

Singapore Management University Singapore, Singapore yueduan@smu.edu.sg

Zhejiang University Hangzhou, China zhaoziming@zju.edu.cn

Xiaofei Yue

Zhaoxuan Li

Beijing Institute of Technology Beijing, China xfyue@bit.edu.cn

Institute of Information Engineering, CAS & University of Chinese Academy of Sciences Beijing, China lizhaoxuan@iie.ac.cn

Abstract Quantum software spans applications, program representations, compilers, runtimes, and hardware-facing control. Existing abstractions describe these artifacts and layers, but they do not capture the semantic responsibilities that must remain valid as a computation is transformed across the stack. This limits systematic reasoning about cross-layer correctness, evolution, and reuse. We present QGenome, a semantic foundation for quantum software genomics. We define a quantum software gene as a typed, reusable responsibility characterized by an explicit contract, execution context, concrete expressions, and supporting evidence. QGenome organizes genes across five software strata and ten responsibility families grouped into computational semantics, coordination, realization, and assurance. Typed genes compose into pathways and genomes through dependency, refinement, provenance, and phenotype relations, enabling responsibilities to be traced across alternative implementations and execution contexts. We illustrate the taxonomy using representative public artifacts across the quantum software stack and define principles for contextual validity, genome evolution, environmental adaptation, and capability expression. Rather than presenting a complete taxonomy or an automated extraction technique, QGenome establishes a falsifiable framework and a concrete research agenda for gene mining, lineage recovery, cross-layer regression testing and repair, and evidence-grounded quantum software agents.

CCS Concepts • Software and its engineering → Abstraction, modeling and modularity; • Computer systems organization → Quantum computing.

Keywords Quantum Software, Software Genomics, Software Evolution

This work is licensed under a Creative Commons Attribution 4.0 International License. SWGeno ’26, Munich, Germany © 2026 Copyright held by the owner/author(s). ACM ISBN 979-8-4007-3002-3/2026/10 https://doi.org/10.1145/3844178.3844646

ACM Reference Format: Jiongchi Yu, Yue Duan, Ziming Zhao, Xiaofei Yue, and Zhaoxuan Li. 2026. The Gene Is Not the Gate: Conceptualizing the Semantic Genome of Quantum Software. In Proceedings of the 2nd International Workshop on Software Genomics (SWGeno ’26), October 12–16, 2026, Munich, Germany. ACM, New York, NY, USA, 4 pages. https://doi.org/10.1145/3844178.3844646

1

Introduction

Quantum software spans a layered ecosystem from application abstractions to hardware-facing control. Circuits, source programs, intermediate representations, runtimes, and control systems expose different stages of this stack [2, 6–8, 12, 15, 16]. These abstractions describe where a computation is represented or transformed, but they do not identify the finer-grained semantic responsibilities that must remain valid across layers. Bell-state preparation illustrates this gap. Its meaning lies in the state relation established between two logical qubits rather than in a specific realization such as H followed by CX. A compiler may decompose or reroute these operations as long as the intended relation is preserved. The same requirement becomes more demanding in teleportation, where measurement outcomes must control corrections on another qubit. A simulator may execute this workflow, while a target backend may lack the required control capability or timing support. Calibration changes can further alter the physical realization without modifying the source program or its intermediate representation. These cases are therefore different expressions of related semantic responsibilities rather than isolated artifacts. Existing abstractions do not expose these relationships directly. Gate motifs capture local implementations, while stack models record transformation locations. Neither states what must be preserved or what evidence supports that preservation. This limitation also extends beyond gate-model programs. Tierkreis, Pulser, and Qibolab expose workflow, pulse-control, and hardware-facing responsibilities that cannot be reduced to a single notion of a quantum program [4, 14, 15]. Even measurement serves different purposes in application readout, syndrome extraction, and controller discrimination. The appropriate unit of analysis must therefore be finer-grained than a software product, richer than a syntactic pattern, and explicitly tied to both semantic role and software stratum. This need is consistent with evidence that quantum software faults

SWGeno ’26, October 12–16, 2026, Munich, Germany

Jiongchi Yu, Yue Duan, Ziming Zhao, Xiaofei Yue, and Zhaoxuan Li

Workflow

Program

Compiler

Runtime

Control

Application / Protocol

Source Code / Circuit / IR

Translate / Map / Schedule

Orchestration / Management

Pulse / Readout / Calibrate

Semantic

State / Transformation / Interaction / Observation

Coordination

Resource Lifecycle / Orchestration

Typed Quantum Gene Card

Realization

Translation / Mapping / Control / Calibration

g=⟨ρ,L,R,Φ,K,X,V⟩

Assurance

Protection / Validation

Genome Graph

Dependency

Refinement

Provenance

Phenotype

Figure 1: QGenome separates software strata from responsibility families. A typed gene card connects both dimensions through an explicit semantic contract, while genome graphs relate gene cards through dependency, refinement, provenance, and phenotype links. often emerge from interactions among source code, circuits, qubit usage, and platform behavior [9, 11]. Position. We define a quantum software gene as a typed, reusable semantic responsibility with a contract that remains checkable across the strata required for its realization. Each gene records its semantic subject, layer span, execution context, observable expressions, and supporting evidence, covering applications, compilers, runtimes, controllers, workflows, simulators, and assurance tools. We introduce QGenome, as shown in Figure 1, which organizes these responsibilities as typed gene cards across software strata and responsibility families. Contracts, dependencies, refinement, provenance, and cross-layer expression relations compose genes into pathways and genomes. QGenome is an extensible foundation, not a complete taxonomy or automatic extraction method.

2

Conceptual Foundations

Quantum Software Genes. We define a quantum software gene as a reusable semantic responsibility whose realization and preservation can be traced across the relevant software strata. A gene associates this responsibility with the software object that owns or enforces it, an explicit semantic contract, and the context and evidence needed to justify its realization. Here, ownership refers to the program element, compiler pass, runtime service, control module, or other software object responsible for satisfying the contract. Unlike a design pattern, intermediate representation, component, or test, a gene connects these artifacts through a shared and checkable semantic obligation. We represent a gene card as 𝑔 = ⟨𝜌, 𝑂, 𝐿, 𝐹, 𝑅, Φ, 𝐾, 𝑋, 𝑉 ⟩. Here, 𝜌 captures the semantic responsibility and contract subject, 𝑂 its owner, 𝐿 its layer span, 𝐹 its taxonomy labels, and 𝑅 its resource roles. The contract Φ = (𝐴, 𝐺) specifies the semantic assumptions 𝐴 and guarantees 𝐺 of the responsibility. The context 𝐾 records realization-specific conditions, while 𝑋 denotes the concrete expressions and 𝑉 provides evidence that 𝐾 satisfies 𝐴 and that 𝑋 realizes 𝐺 under 𝐾. Gene identity is determined by 𝜌, 𝑅, and Φ, while versions and lineage are maintained in the genome graph. Scope of Classification. Our taxonomy classifies documented quantum-dependent responsibilities rather than entire repositories. Each candidate must specify a contract subject, an owning

or enforcing software object, at least one observable expression, and public evidence. Candidates with separable obligations over different subjects are split into gene cards linked by dependency or refinement. Multiple family labels are used only for inseparable cross-family obligations. Insufficiently evidenced candidates remain unresolved rather than established genes.

3

Quantum Software Gene Taxonomy

QGenome classifies each gene along two orthogonal axes. The software-stratum axis identifies where a responsibility is realized, while the responsibility-family axis specifies the semantic obligation it governs. This separation is necessary because one responsibility may span multiple strata, while one software system may own several kinds of genes [5, 8]. As summarized in Table 1, the taxonomy contains ten responsibility families organized into four groups: computational semantics, coordination, realization, and assurance. Computational Semantics. These genes govern how quantum information is prepared, transformed, related, and observed. State, transformation, interaction, and observation genes capture these respective responsibilities. They are reusable across algorithms: teleportation composes state and observation genes with classically controlled correction, while VQE combines state and transformation genes with observation in a classical optimization loop. Coordination. These genes organize resources and hybrid execution. Resource-lifecycle genes govern allocation, reset, reuse, and release, whereas orchestration genes capture dependencies between quantum execution and classical control. Tierkreis realizes orchestration through typed quantum-classical workflows, while XACC/qcor coordinates quantum kernels, accelerator selection, and hybrid execution [7, 8, 15]. Realization. These genes connect abstract computations to executable device operations. Translation genes preserve meaning across source, IR, and native representations. Mapping-and-timing genes bind logical operations to physical resources and schedules. Control-and-calibration genes connect scheduled operations to signals and device parameters. OpenQL exposes translation and mapping responsibilities, while Pulser and Qibolab provide different forms of pulse-level and hardware-facing control [4, 6, 14].

The Gene Is Not the Gate: Conceptualizing the Semantic Genome of Quantum Software

Assurance. These genes establish or preserve claims about correctness and execution quality. Protection-and-validation genes include program analyses, simulation, diagnostics, mitigation, and benchmark oracles. LintQ and MorphQ validate program and transformation properties, whereas MQT Bench and Bugs4Q provide cross-level artifacts and reproducible evidence [10, 11, 13, 18]. Although these systems belong to the same family, they validate different contract subjects. Scope and Relative Completeness. The taxonomy covers responsibilities whose correctness depends on a quantum-specific state, operation, resource, capability, timing condition, noise model, or statistical obligation. Purely classical functionality remains outside this scope unless it affects such a contract. Let Q denote the scoped responsibilities, L the software strata, and F the responsibility families. We define set-valued typings 𝜆 : Q → 2 L , 𝜏 : Q → 2 F , and the uncovered set 𝑈 = {𝑞 ∈ Q | 𝜆(𝑞) = ∅ ∨ 𝜏 (𝑞) = ∅}. A responsibility may receive multiple labels, provided that each denotes a distinct contract subject. We claim only relative completeness for the current catalog: new elements of 𝑈 may reveal missing categories or refine existing boundaries.

4

Genome Lifecycle Construction

Construction and Composition. A quantum software genome instantiates the taxonomy by connecting typed gene cards into executable pathways. Genome construction identifies semantic responsibilities, assigns their strata and families, binds concrete expressions, and records dependency and refinement relations together with versioned evidence. Different software classes naturally exhibit different profiles: applications emphasize computational semantics, compilers emphasize translation and mapping, runtimes emphasize coordination, and controllers and analysis tools emphasize control and assurance. These profiles are not fixed labels, since one system may own several gene types and one gene may have multiple backend-specific expressions. Static analysis, metamorphic testing, simulation, execution, and calibration can provide evidence at different strata [10, 11]. Contextual Validity. A genome is valid only under a declared execution context. Its genes must satisfy local contracts, compose consistently, preserve higher-level responsibilities across refinement, and rely on applicable evidence: Valid(Γ, 𝐾) = Local(Γ, 𝐾) ∧ Compose(Γ) ∧ Refine(Γ, 𝐾) ∧ Fresh(𝑉 , 𝐾). A successful execution alone is insufficient, as it may conceal mapping errors, untested branches, or stale calibration evidence. Genome Evolution. A genome evolves through changes to its responsibilities, pathways, expressions, contexts, or evidence. Expression variation changes an implementation while preserving its contract, such as a revised gate decomposition or pulse schedule. Pathway recombination changes gene composition, as when qubit reuse introduces measurement and reset responsibilities [3]. Contract mutation instead changes the promised semantics, such as replacing an exact transformation with an approximate one. These distinctions separate contract-preserving implementation changes from semantic changes or violations across genes. Environmental adaptation re-expresses a stable responsibility under a new execution context 𝐾 ′ . Retargeting is valid only when 𝐾 ′ |= 𝐴, (𝑋 ′, 𝐾 ′ ) |= 𝐺, and the evidence 𝑉 ′ adequately supports

SWGeno ’26, October 12–16, 2026, Munich, Germany

these claims. Depending on the contract Φ, the correspondence between the original and adapted expressions may be exact, approximate, or statistical. This distinction is particularly important for hardware-facing systems such as Pulser and Qibolab, where device capabilities and configurations affect realization validity [4, 14]. Phenotypic measures such as fidelity, latency, success probability, and resource cost may guide the selection among valid adaptations, but do not determine gene identity.

5

Capability Expression and Engineering Uses

From Validity to Capability. QGenome connects cross-stratum validity to observable software capabilities. A phenotype is an observation produced by a genome under a declared context, whereas a capability is a set of supported phenotypes with explicit operating conditions. This distinction prevents a successful execution from being generalized into an unsupported capability claim. Phenotypes vary across software strata. Applications expose output quality and protocol success, compilers expose semantic preservation and resource overhead, runtimes expose execution and feedback behavior, and control software exposes signal validity and calibration quality. Assurance tools further characterize detected violations and validation coverage. A capability claim is justified only when the relevant genome pathway is valid under the declared context and the collected observations satisfy its acceptance criteria with sufficient evidence. Capability assessment must therefore distinguish the validity of the pathway, the conditions under which it is realized, and the evidence supporting its observed behavior. Engineering Uses. By making responsibilities, contexts, and evidence explicit, QGenome supports several engineering tasks. Reuse transfers gene cards and pathways together with their assumptions, so incompatible contexts trigger adaptation rather than silent transplantation. Testing measures coverage over responsibilities and refinement edges instead of only statements or gates. Existing resources such as MorphQ, MQT Bench, and Bugs4Q can provide evidence for these checks [10, 13, 18]. Repair can target the earliest violated contract, while change-impact analysis follows dependency, refinement, and evidence-freshness relations. Gene cards can also serve as typed planning artifacts for autonomous engineering agents. An implementation agent proposes an expression, a backend-aware agent checks its context and resource assumptions, and a verification agent supplies supporting evidence. Existing verifier-in-the-loop and closed-loop QPU systems show that such executable feedback is increasingly available [1, 17]. QGenome does not make an agent trustworthy by itself. Instead, it specifies the contract, context, and evidence that must be established before an agent-generated action is accepted.

6

Future Research Directions

QGene Atlas and Benchmark. A first direction is to build a versioned atlas of quantum software genes across applications, compilers, runtimes, control systems, simulators, and assurance tools. The atlas should record gene cards, pathway relations, concrete expressions, contexts, and evidence rather than treating repositories as indivisible samples. It can support tasks such as gene-boundary detection, family classification, cross-stratum linking, and contract

SWGeno ’26, October 12–16, 2026, Munich, Germany

Jiongchi Yu, Yue Duan, Ziming Zhao, Xiaofei Yue, and Zhaoxuan Li

Table 1: QGenome responsibility taxonomy. Each gene is typed by its software stratum. Group

Family

Semantic responsibility

Representative contract focus

Semantic Semantic Semantic Semantic

State Transformation Interaction Observation

Establish or encode a quantum state Change quantum information coherently Create or consume quantum relations Produce interpretable evidence

Bell/GHZ preparation, ansatz initialization, state relation QFT, oracle, compute–uncompute, pre/post relation Controlled operations, entanglement, resource roles Basis measurement, syndrome processing, bit mapping

Coordination Coordination

Resource lifecycle Orchestration

Govern resource phases Order quantum and classical work

Allocation, reset, reuse, cleanliness, ownership Feedforward, hybrid loops, dependency, latency

Realization Realization Realization

Translation Mapping & timing Control & calibration

Lower representations while preserving meaning Bind logical space and time to a target Bind operations to physical signals

Decomposition, optimization, semantic refinement Placement, routing, scheduling, map consistency Pulse and readout synthesis, calibration freshness

Assurance

Protection & validation

Establish or preserve software claims

QEC, mitigation, analysis, simulation, oracles

extraction. Annotation agreement and unresolved cases should guide future revisions of the taxonomy. Automated Gene Mining and Lineage Recovery. Future work can recover gene cards and their evolution from software artifacts. Static analysis can identify resource roles and transformation boundaries, while execution traces reveal runtime dependencies and hardware interactions. IR provenance and version history can link source responsibilities to compiled and deployed expressions. A practical interchange format should capture expressions, refinement relations, evidence validity, and phenotype observations. Gene-Aware Regression Testing and Repair. QGenome enables cross-layer regression analysis beyond circuit syntax. Compiler or calibration changes may violate contracts without changing the program. Future systems can mutate gene cards and refinement edges, generate contract-oriented tests, and localize failures to violated responsibilities. Versioned compiler, runtime, and calibration benchmarks can further evaluate gene-aware fault localization and contract-guided repair. Evidence-Grounded Quantum Software Agents. Quantum software agents should produce validated genome updates, not just circuits or configurations. Each update should specify affected responsibilities, required context, proposed expressions, and supporting evidence. This supports backend-aware mapping, testing, workflow adaptation, repair, and retargeting. Evaluation should consider contract coverage, unsupported assumptions, evidence freshness, cross-layer consistency, and adaptation to environmental changes alongside task success.

7

Conclusion

In this paper, we introduced QGenome, a semantic foundation for understanding quantum software beyond gates, circuits, and repository boundaries. We define quantum software genes as typed, reusable responsibilities with explicit contracts, contexts, expressions, and evidence, and organize them across five software strata and ten responsibility families. QGenome provides a common vocabulary for tracing how quantum-dependent responsibilities are realized, composed, and preserved across the stack, enabling future gene-aware analysis, testing, repair, evolution, and autonomous quantum software engineering.

References [1] Shuxiang Cao, Zijian Zhang, Mohammed Alghadeer, Simone D Fasciati, Michele Piscitelli, Mustafa Bakr, Peter Leek, and Alán Aspuru-Guzik. 2025. Automating quantum computing laboratory experiments with an agent-based AI framework. Patterns 6, 10 (2025). doi:10.1016/j.patter.2025.101372

[2] Andrew Cross et al. 2022. OpenQASM 3: A broader and deeper quantum assembly language. ACM Transactions on Quantum Computing 3, 3 (2022), 1–50. doi:10. 1145/3505636 [3] Matthew DeCross, Eli Chertkov, Megan Kohagen, and Michael Foss-Feig. 2023. Qubit-reuse compilation with mid-circuit measurement and reset. Physical Review X 13, 4 (2023), 041057. doi:10.1103/PhysRevX.13.041057 [4] Stavros Efthymiou, Alvaro Orgaz-Fuertes, Rodolfo Carobene, Juan Cereijo, Andrea Pasquale, Sergi Ramos-Calderer, Simone Bordoni, David Fuentes-Ruiz, Alessandro Candido, Edoardo Pedicillo, et al. 2024. Qibolab: an open-source hybrid quantum operating system. Quantum 8 (2024), 1247. doi:10.22331/q-202402-12-1247 [5] Thomas Häner, Damian S Steiger, Krysta Svore, and Matthias Troyer. 2018. A software methodology for compiling quantum programs. Quantum Science and Technology 3, 2 (2018), 020501. doi:10.1088/2058-9565/aaa5cc [6] Nader Khammassi, Imran Ashraf, JV Someren, Razvan Nane, Anna M Krol, M Adriaan Rol, Lingling Lao, Koen Bertels, and Carmen G Almudever. 2021. OpenQL: A portable quantum programming framework for quantum accelerators. ACM Journal on Emerging Technologies in Computing Systems (JETC) 18, 1 (2021), 1–24. doi:10.1145/3474222 [7] Alexander Mccaskey, Thien Nguyen, Anthony Santana, Daniel Claudino, Tyler Kharazi, and Hal Finkel. 2021. Extending C++ for heterogeneous quantumclassical computing. ACM Transactions on Quantum Computing 2, 2 (2021), 1–36. doi:10.1145/3462670 [8] Alexander J McCaskey et al. 2020. XACC: a system-level software infrastructure for heterogeneous quantum–classical computing. Quantum Science and Technology 5, 2 (2020), 024002. doi:10.1088/2058-9565/ab6bf6 [9] Matteo Paltenghi and Michael Pradel. 2022. Bugs in quantum computing platforms: an empirical study. Proceedings of the ACM on Programming Languages 6, OOPSLA1 (2022), 1–27. doi:10.1145/3527330 [10] Matteo Paltenghi and Michael Pradel. 2023. MorphQ: Metamorphic testing of the Qiskit quantum computing platform. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE, 2413–2424. doi:10.1109/ ICSE48619.2023.00202 [11] Matteo Paltenghi and Michael Pradel. 2024. Analyzing quantum programs with lintq: A static analysis framework for qiskit. Proceedings of the ACM on Software Engineering 1, FSE (2024), 2144–2166. doi:10.1145/3660802 [12] QIR Alliance. 2026. What is QIR? https://www.qir-alliance.org/qir-book/ concepts/what-is-qir.html. Accessed 2026-07-20. [13] Nils Quetschlich, Lukas Burgholzer, and Robert Wille. 2023. MQT Bench: Benchmarking software and design automation tools for quantum computing. Quantum 7 (2023), 1062. doi:10.22331/q-2023-07-20-1062 [14] Henrique Silvério et al. 2022. Pulser: An open-source package for the design of pulse sequences in programmable neutral-atom arrays. Quantum 6 (2022), 629. doi:10.22331/q-2022-01-24-629 [15] Seyon Sivarajah, Lukas Heidemann, Alan Lawrence, and Ross Duncan. 2022. Tierkreis: A dataflow framework for hybrid quantum-classical computing. In 2022 IEEE/ACM Third International Workshop on Quantum Computing Software (QCS). IEEE, 12–21. doi:10.1109/QCS56647.2022.00007 [16] Damian S Steiger, Thomas Häner, and Matthias Troyer. 2018. ProjectQ: an open source software framework for quantum computing. Quantum 2 (2018), 49. doi:10.22331/q-2018-01-31-49 [17] Cong Yu et al. 2026. Vista: Verifier-in-the-Loop Agentic Reinforcement Learning for Quantum Program Synthesis. In Proceedings of the ACM Conference on AI and Agentic Systems. 239–252. doi:10.1145/3786335.3813148 [18] Pengzhan Zhao, Zhongtao Miao, Shuhan Lan, and Jianjun Zhao. 2023. Bugs4Q: A benchmark of existing bugs to enable controlled testing and debugging studies for quantum programs. Journal of Systems and Software 205 (2023), 111805. doi:10.1016/j.jss.2023.111805

Received 2026-07-25; accepted 2026-08-21

Related documents

• QPipe: LLM-Based Agentic Quantum Application Generation for Test Optimization#1585764
• Query-Limited RAM Programs and their Applications#1154458
• Query-Limited RAM Programs and their Applications#1136752
• A Dynamic Intermediate Representation for Hybrid Quantum-Classical Programs#821025
• Perspective on AI and quantum open-source software#1488841