WorksComputer Science
QSoftCore: A Conceptual Foundation for Quantum Software Engineering
Abstract
Quantum software engineering (QSE) requires understanding application requirements, quantum programs and algorithms, quantum computation paradigms, executions, and deployment. However, relevant quantum computing (QC) concepts are often defined across physical, mathematical, and paradigm-specific levels of abstraction, making it difficult for the QSE community and hence proposed methods to refer to them consistently. To this end, we present QSoftCore, a conceptual model that reorganizes established QC concepts from a software engineering perspective and connects quantum applications, computational problems, algorithms, configurations, programs, and paradigm-specific computation specifications with state evolution, execution results, and backends. Our assessment against QSE literature across key software engineering activities indicates that QSoftCore provides shared QC referents for quantum computations, executions, deployment configurations, backends, and measurement evidence across the QSE lifecycle.
Introduction
Quantum computing (QC) is becoming a software-intensive discipline: applications increasingly rely on programming languages, compilers, software development kits, workflow engines, cloud platforms, simulators, quantum processing units (QPUs), and classical components. Accordingly, quantum software engineering (QSE) now addresses activities across the software lifecycle [1, 2, 3, 4], including requirements [5, 6], architecture [7, 8], implementation, testing [9, 10], and debugging [11, 12].
These activities must relate application requirements to a computational problem and an algorithmic choice, distinguish a source program from the computation it constructs, connect a logical specification to its compiled and deployed realization, and interpret execution results under sampling, noise, calibration, and backend assumptions. Existing QC explanations, however, are commonly structured around subjects weakly aligned with classical software engineering, such as physical and mathematical conceptions, abstruse algorithmic principles, or particular computation paradigms [13]. QSE studies consequently tend to introduce the QC concepts needed for an individual task, often with a gate-based and circuit-centered focus [4, 14, 15].
To address this gap, this paper presents QSoftCore, a conceptual model that reorganizes established QC concepts from a software engineering (SE) perspective. Rather than introducing a new quantum formalism or reproducing general SE taxonomies, QSoftCore organizes QSE-relevant QC concepts into five views: 1) applications and software systems, linking requirements and computational problems to algorithms, configurations, and software components; 2) computation specifications for gate-based, analog, quantum-annealing, and measurement-based paradigms; 3) gate-based computation, detailing the circuits, operations, qubits, and states on which most current QSE work rests; 4) execution and evolution, separating the intended computation from a concrete run and its runtime evidence; and 5) deployment, relating logical specifications to backend-specific artifacts, including mappings, calibration, noise, and physical resources. Two worked application examples then connect these views.
We assess QSoftCore against the QSE literature: across the activities the literature addresses, we check whether the QC concepts required are represented by QSoftCore, distinguishing QC concepts (e.g., a quantum circuit) from task-specific SE artifacts (e.g., a test case). Across requirements, architecture design, code generation, execution and deployment, and quality assurance, the assessment finds that the QSE literature is predominantly gate-based and circuit-centered, remains close to programming-level abstractions, and offers limited support for application-level and hybrid design, alternative computation paradigms, deployment reasoning, and interpreting simulator- and QPU-derived evidence. QSoftCore therefore covers the QC concepts these works use and adds explicit representations for alternative paradigms, quantum evolution, deployment context, execution evidence, and raw versus mitigated results, offering QSE methods and tools a shared QC vocabulary for defining and tracing artifacts across activities. By giving QSE a shared QC vocabulary, QSoftCore allows researchers, tool builders, and practitioners to describe algorithms, programs, executions, and deployment contexts in comparable terms, so that artifacts, assumptions, and evidence can be reused across methods, tools, and studies rather than re-encoded for each one.
Structure. Section 2 presents QSoftCore, which is assessed in § 3. Section 4 concludes the paper.
Conceptual Model: QSoftCore
This section presents QSoftCore, the SE-oriented conceptual model of QC. We specify it using Unified Modeling Language (UML) class diagrams, with each diagram presenting one connected view of the concepts and relationships. Its goal is not to redefine established quantum notions, but to reorganize them into a structure that is easier to use for QSE.
Scope and Organization of QSoftCore
QSoftCore aims to help the QSE community understand QC systematically without requiring intensive study of quantum physics or mathematical formalism. First, concepts from the mathematical and physical foundations of QC are included only when they influence SE activities and their empirical settings. Second, QC is modeled in its SE context, so that quantum concepts are related to programs, computations, executions, deployment configurations, backends, and result evidence rather than treated as isolated mathematical or physical notions.
The rest of this section introduces QSoftCore incrementally, following the path from an application need to computation design, execution, and deployment. The application and software-system view (§ 2.2) begins with familiar SE concerns and explains how an application need is formulated as a computational problem, constrained by requirements, addressed by a selected algorithm, and implemented in software. The computation-paradigm view (§ 2.3) then explains that quantum computations can be realized in different ways, named computation paradigms, and introduces how a computation is described in each. Because current QSE studies primarily address gate-based computation, in which a computation is expressed as a sequence of discrete steps, the gate-based computation view (§ 2.4) examines this form in greater detail. The execution and evolution view (§ 2.5) next distinguishes the intended computation from a concrete run, what happens during that run, and the results observed. The deployment view (§ 2.6) explains how a computation is prepared for a simulator or physical quantum computer and how platform conditions affect its execution. Finally, the application examples (§ 2.7) connect these views in two worked cases. Note that like many SE artifacts, QSoftCore is incomplete by design and should evolve with QC technologies and QSE practices.
Application and Software System View
Figure 1 positions a quantum application as a software system that uses QC for solving application problems such as optimization and simulation [4]. In QSoftCore, an application is “quantum” when its component structure includes at least one QuantumProgram, which subsequently contains one or more QuantumSubroutine instances, each representing a reusable portion of quantum computation that the program can invoke. Classical components may prepare inputs, coordinate workflows, invoke quantum computations, interpret results, or integrate the application with external systems.
Figure 1. Application and software-system view. The diagram connects requirements and computational problems to algorithm configurations, quantum programs and their subroutines, software components, and execution relations.
An Application requires solutions to address one or more ComputationalProblem instances. Identifying the computational problem is critical in QSE because it is the point at which an application need becomes a computation-level contract. If this contract is vague, later choices about data encoding, circuit or Hamiltonian formulation, backend suitability, etc. become underspecified. In QSoftCore, a ComputationalProblem records the problem kind, expected input, validity condition for solutions, and, where relevant, an optimization or estimation objective.
For SE readers, ProblemKind is a property of a ComputationalProblem classifying its input-output contract; it is settled before the later algorithm, encoding, and paradigm choices, which it helps narrow without determining. Five literals are mutually exclusive because they are distinguished by output type: a Boolean (decision), any satisfying artifact (search), the artifact optimizing a stated objective (optimization), a value within a specified error (estimation), or a set of instances drawn from a target distribution (sampling). A sixth literal, other, is reserved for future extension. A decision problem asks whether a given input satisfies a Boolean property, which produces a yes-or-no answer such as checking whether a feature configuration in a product line context is valid [16]. A search problem returns any artifact satisfying a condition, such as finding a program satisfying a specification [17]. An optimization problem returns a feasible artifact that optimizes a stated objective, such as a subset of a test suite [18]. An estimation problem aims to approximate a numerical value within a specified error or confidence requirement. For instance, in hybrid QC workflows, repeated quantum executions produce measurement samples that are classically aggregated to estimate quantities such as Pauli-string expectation values [19]. A sampling problem aims to generate instances from a target distribution, rather than finding any valid instance as in search or the best instance as in optimization. Note that a simulation or learning problem, common in QSE, is covered by one of these literals according to its deliverable: simulation, for example through Hamiltonian simulation [20], is an estimation problem whose target is a property of the modeled system; a learning problem, such as a hybrid quantum-machine-learning test oracle that learns expected robot behavior from historical data for regression testing [21], is a decision or estimation problem according to whether its output is a label or a value.
The application also contains one or more Requirement instances. Requirements are critical in QSE because feasibility and quality must often be reasoned about early using quantum-specific constraints, such as available qubits, backend access, noise, execution budget, and acceptable failure probability [5]. QSoftCore uses Requirement only as a bridge from application needs to AlgorithmConfiguration; it does not remodel requirements engineering concepts already established in SE.
A QuantumAlgorithm represents a reusable quantum solution approach that is independent of a particular application or execution environment. It can employ one or more algorithmic techniques or building blocks such as the quantum Fourier transform (QFT), phase estimation, amplitude amplification, amplitude estimation, variational optimization, quantum walks, or Hamiltonian evolution [13, 22].
An AlgorithmConfiguration represents the selection and application-specific tailoring of such an algorithm. It connects a general QuantumAlgorithm to the ComputationalProblem for which it is selected and to the Requirement instances that constrain the selection. Its rationale records why the algorithm and its particular configuration were considered appropriate. The configuration may capture decisions concerning algorithm parameters, encoding, oracle construction, error tolerance, classical—quantum partitioning, and resource limits. For example, the quantum approximate optimization algorithm (QAOA) is a reusable variational method; in IGDec-QAOA for test case optimization, the configuration includes the optimization objective encoding, quadratic unconstrained binary optimization (QUBO) formulation, decomposition strategy, circuit-depth, and backend or noise assumptions [18]. The distinction between QuantumAlgorithm and AlgorithmConfiguration is important for QSE: the former represents a reusable method with abstraction, whereas the latter helps instantiate that method into a concrete solution and documents how and why it is tailored to a specific engineering context.
An AlgorithmConfiguration is realized by one or more QuantumComputationSpecification (QCS) instances, which give the configured computation its paradigm-specific form rather than assuming a gate-based circuit. For instance, IGDec-QAOA realizes test case optimization through gate-based QAOA circuits [18], whereas BootQA realizes test case minimization by quantum annealing [9]. These illustrate different configurations. A single configuration may still have several specifications when the selected algorithm, problem encoding, and constraints remain fixed. For example, the same QAOA configuration with a fixed QUBO encoding and circuit depth may be represented by multiple equivalent logical circuits.
Relying on the degree of code abstraction, a QuantumProgram can implement one or more AlgorithmConfiguration instances and construct or invoke one or more QCS instances. Reminding that the algorithm configuration captures the selected and tailored solution strategy, whereas the QCS captures the concrete quantum computation that realizes that strategy, a quantum program provides the executable software that connects the two concepts to the remainder of the application. More specifically, the quantum program may prepare input data, bind parameters, construct circuits or energy models, submit computations to a backend, coordinate classical feedback, and process the resulting classical outputs. A QuantumProgram may be executed zero or more times: it may remain defined without being invoked, or it may have multiple runtime executions, each represented by a QuantumExecution. This separates the reusable software definition from its concrete runtime occurrences and allows programs to be modeled before execution. The runtime details of execution and results are discussed in the execution and evolution view (§ 2.5).
Overall, this view establishes the abstraction path followed by QSoftCore: an application need is expressed as a computational problem and constrained by requirements; an algorithm is then selected and configured; the configuration is realized as a paradigm-specific computation specification; and executable programs connect that specification to the surrounding software system. This keeps quantum application engineering grounded in familiar SE abstractions while making explicit where QC-specific decisions enter. The following views refine the computation, operation, execution, evolution, hardware, and deployment concepts introduced here.
Quantum Computation Paradigm View
As shown in Figure 2, a QCS specifies the paradigm-specific structure of the quantum computation used to realize the algorithm selected and tailored by an AlgorithmConfiguration. Different quantum computation paradigms specify computation through different metaclasses, e.g., GateBasedComputation is represented by a QuantumCircuit [13]; AnalogComputation by a HamiltonianModel and ControlSchedule [23]; QuantumAnnealingComputation by an EnergyModel [24]; and MeasurementBasedComputation by a MeasurementPattern for measurement-based quantum computation (MBQC) [25]. QSoftCore treats the paradigm hierarchy as incomplete and overlapping: new paradigms can be added. Well-known platforms and software ecosystems illustrate the distinction: IBM Quantum provides access to circuit-based QC services [26]; D-Wave systems expose annealing over Ising or QUBO models [27], QuEra’s Aquila supports analog Hamiltonian simulation [28], and Xanadu describes a photonic MBQC architecture [29].
Figure 2. Quantum-computation paradigm view. The diagram represents computation specifications as circuits, Hamiltonian models with control schedules, energy models, or measurement patterns, with illustrative well-formedness constraints.
A GateBasedComputation specifies a computation via discrete quantum operations organized as a QuantumCircuit [13]. Because circuit-based abstractions appear frequently in the QSE literature, their qubits, states, operations, and circuit structure are discussed separately in § 2.4.
An AnalogComputation specifies a computation through the continuous-time evolution of a quantum system under a possibly time-dependent Hamiltonian, a mathematical operator that describes the system’s energy structure and governs how its quantum state evolves over time. A HamiltonianModel is a software-level representation of a mathematical Hamiltonian. It records the Hamiltonian’s terms, coefficients, parameters, and, where applicable, time dependence, so that the Hamiltonian can be constructed, transformed, validated, simulated, and adapted for deployment. A ControlSchedule specifies how externally controllable parameters of the Hamiltonian vary over time. Together, the Hamiltonian model and control schedule determine the intended evolution, and an initial QuantumState provides its starting condition.
A QuantumAnnealingComputation is an optimization subtype of AnalogComputation. It applies when an application-level ComputationalProblem has ProblemKind::optimization (Figure 1) and an AlgorithmConfiguration selects annealing as the strategy. In QSoftCore, the EnergyModel is the optimization artifact: it states the objective over DecisionVariable instances as an Ising, QUBO, higher-order binary, etc. QUBO and higher-order binary models use variables in , whereas Ising models use spins in . Application-level variables with other variables such as integer, real-valued, or categorical variables, must first be mapped to binary variables or Ising spins, with any necessary constraints incorporated into the model. For execution, the energy model is represented as a problem Hamiltonian whose low-energy states correspond to better solutions and whose ground states represent optima. The annealing process is still analog: the full time-dependent evolution Hamiltonian includes this problem Hamiltonian and is driven by a ControlSchedule toward low-energy states [24]. In QSE, this modeling approach is used when test case minimization is encoded as a QUBO for quantum annealers [9], when test optimization is formulated as Ising models for Ising-based solvers and benchmarks [30], and when dynamic analysis of D-Wave programs recovers Hamiltonian expressions representing the underlying optimization problem definitions [31].
An AdiabaticComputation is an AnalogComputation whose Hamiltonian changes gradually from an initial to a final Hamiltonian according to a ControlSchedule [32]. The initial Hamiltonian is chosen so that its relevant low-energy state can be prepared, while the final Hamiltonian encodes the intended computational result. Under the adiabatic condition, the system remains close to the corresponding instantaneous eigenstate during the evolution. A QuantumAnnealingComputation may use this adiabatic principle when its annealing schedule slowly moves from a driver Hamiltonian to the problem Hamiltonian.
An AnalogQuantumSimulation uses an engineered quantum system to reproduce or approximate another, target system whose behavior is impractical to obtain through direct experiments or classical simulation at the required scale, such as a molecule or magnetic material [23]. Its targetHamiltonian describes the closed-system model to be simulated; the computation prepares an initial state, configures an implemented Hamiltonian, evolves the system, and measures Observable instances, i.e., properties of the simulated system that the application wants to estimate. Examples include the system’s energy, the number of particles or excitations, or correlations between parts of the system. The implemented Hamiltonian may equal the target Hamiltonian in a direct simulation or approximate it through an experimentally realizable mapping. This distinction between target and implemented Hamiltonians is reflected in software support for analog quantum simulation. For example, SimuQ lets users specify a target Hamiltonian, such as an Ising spin model, and compile it to realizations on devices such as neutral-atom arrays, superconducting transmon systems, and trapped-ion systems [20]. Classical simulators provide related but distinct support: QuTiP’s pulse-level engine numerically integrates Hamiltonians, control pulses, and noise models on a conventional computer to emulate hardware-aware circuit behavior [33].
In MBQC, a computation prepares an entangled resource state and then proceeds through a sequence of measurements. This should not be confused with measurement outcomes or records used as observations in SE tasks such as testing and debugging [14, 34]. In QSoftCore, a MeasurementBasedComputation captures this paradigm through a MeasurementPattern [25]. MBQC has been demonstrated with photonic cluster states and trapped ions [35, 36]. The pattern is the main engineering artifact: it specifies which subsystems are measured, which bases or angles are used, how later measurements depend on earlier outcomes, and which classical feed-forward corrections are applied. Measurement is therefore part of the computation, not only its final readout, which changes what must be specified, tested, and verified.
These paradigms also lead to different engineering artifacts. Gate-based specifications are refined through circuits, native-operation sets, and qubit mappings; annealing specifications through energy models and embeddings; analog specifications through Hamiltonians and control schedules; and MBQC specifications through resource states and adaptive measurement patterns. QSoftCore therefore treats QCs as an extensible abstraction so that QSE methods can refer to paradigm-specific artifacts without assuming that every computation is ultimately circuit-based.
Gate-Based Computation View
Gate-based computation is currently the most extensively represented form of QC in QSE, in modeling and code-generation tools [37, 38] and especially in quantum software and program testing [14, 15, 34, 39, 40, 41, 42]. This focus also reflects the broader QC software stack that QSE methods often target: OpenQASM provides a circuit-oriented assembly language and intermediate representation [43], while Qiskit/IBM Quantum supports circuit construction, transpilation, and backend execution [26]. QSoftCore therefore describes gate-based computation in greater detail than the other computation paradigms, reflecting the present focus of QSE research and practice.
Circuit and Operation View
As shown in Figure 3, a QuantumCircuit represents gate-based computation via QuantumRegister instances that group its Qubit instances. The circuit’s width is derived from the total number of qubits across its registers, while its depth is derived from the stepIndex values assigned to operation applications. For SE, width and depth affect resource estimation, backend feasibility, exposure to noise, testing, and optimization. Operations sharing a stepIndex are only candidates for parallel execution: they may still be serialized if they use the same qubit or if backend constraints prevent parallel execution. QSoftCore distinguishes LogicalCircuit and CompiledCircuit. A logical circuit captures the backend-independent computation, whereas a compiled circuit records the backend-adapted realization produced by compilation. Physical placement is represented by QubitMapping instances in the gate-based deployment artifact discussed in the deployment view (§ 2.6). This distinction matters in SE: it separates circuit-level operands from deployment-specific placement, letting tests, analyses, and defects target either the intended circuit or its deployed realization.
Figure 3. Gate-based operation view. The diagram separates reusable operation definitions from circuit applications and relates operations to operands, parameters, contracts, states, representations, and bases.
A QuantumCircuit contains zero or more OperationApplication instances. Each operation application is one occurrence of a QuantumOperation in the circuit: it records the selected operation, its ordered qubit operands, its stepIndex, and any ParameterBinding instances used in that occurrence. The arity of a QuantumOperation specifies how many operands an application must provide. Each OperationApplication must supply exactly that number of distinct qubits, and each of those qubits must belong to the containing circuit. The order is semantically relevant: for a controlled-NOT (CNOT) gate, the first operand may denote the control qubit and the second the target qubit, so exchanging them changes the operation. These conditions ensure that each operation application conforms to the invoked operation.
A QuantumOperation may own OperationParameter instances, each with a name, a type, an optional valueConstraint, and an optional default. Supported types include the real, integer, and complex numeric domains, as well as semantically constrained reals such as rotation angles (periodic modulo ) and probabilities (bounded in ). A ParameterBinding assigns a concrete value to an OperationParameter at a particular OperationApplication. The distinction is needed because the parameter belongs to the reusable operation definition, while the value belongs to one configured occurrence in a circuit. For example, the same operation can appear several times with different values. Each binding must therefore refer to a parameter owned by the invoked operation, and an operation application should not bind the same parameter more than once. A QuantumOperation may also own an optional OperationContract that records preconditions, postconditions, and invariants, providing an operation-level place to reference assumptions and expected properties used in specification-based testing and test oracles [10, 42] and runtime assertions [44].
QSoftCore distinguishes four kinds of state-affecting quantum operation: Gate, StatePreparation, Reset, and Measurement. They cover the gate-based operation kinds needed here: unitary change, state initialization, state reinitialization, and observation with possible state update. A Gate represents a reversible operation whose semantics is given by one UnitaryOperator; for arity , the unitary matrix has dimension , so reversible holds. A gate has one or more GateFamily values, such as basis-change, rotation, phase, entangling, permutation, oracle, or arithmetic. The families are not exclusive: the Hadamard gate can be treated as basis-changing, as a rotation and phase gate, and CNOT as an entangling controlled gate. The controlCount records the number of control operands and must be smaller than the gate arity. A StatePreparation establishes a designated QuantumState: a single-qubit state such as or , or a possibly multi-qubit, application-specific input state. A Reset reinitializes an operand to a target QuantumState, commonly , so it can be reused or measured again. QSoftCore separates them from gates because they establish state rather than apply a unitary to an operand, and separates reset from state preparation because QSE analyses distinguish input construction from execution-time reset behavior [14, 45]. A Measurement is specified relative to one SystemBasis and is the only operation kind for which producesClassicalOutput holds. It is modeled separately from gates because it is non-unitary, and because the chosen basis determines how quantum state information becomes classical observations. In QSE, measurements link quantum executions to classical evidence.
A QuantumState records whether the state is pure or mixed through PurityKind and may be associated with one or more QuantumStateRepresentation instances. The purity classification separates what kind of state is described from the mathematical form used to express it. For QSE, pure and mixed states need different forms: pure states are expressed as state vectors and suffice for ideal simulation and circuit-level equivalence checking, whereas mixed states are expressed as density operators and are needed for noise, measurement uncertainty, or partial information. Because the same vector or matrix denotes different states under different bases, a representation means nothing without the SystemBasis it was written in. A SystemBasis specifies the number of qubits and the ordered basis vectors used to express states, operators, and measurement outcomes. For qubits, a complete basis contains mutually orthonormal vectors, each of dimension . Testing work depends on the measurement basis, for example when projective tests use computational-basis measurements [42] or when test oracles assume a fixed basis for interpreting outcomes [10]. A StateVectorRepresentation expresses a pure state of an -qubit system as a normalized complex vector with components. A DensityOperatorRepresentation expresses a state as a complex matrix and can represent both pure and mixed states. The OCL constraints in QSoftCore are a subset that targets conceptual-model consistency, such as circuit width, measurement output, and control-count validity, leaving standard mathematical constraints such as vector normalization and operator unitarity implicit.
Overall, the gate-based view connects gate-based computation to familiar SE concerns such as reuse, parametrization, contracts, and transformation, representing each through model constructs such as operation definitions, invocation occurrences, and parameter bindings. These distinctions support traceability from logical circuit specification through compilation, execution, and testing.
Qubit Characterization View
Figure 4 separates qubits used in the logical circuit from qubits provided by hardware. A LogicalCircuit consists of LogicalQubit instances that serve as circuit operands, while a PhysicalQubit is a qubit realized in hardware via a QubitTechnology, e.g., superconducting, trapped-ion, neutral-atom, photonic, or spin. This distinction is central for QSE because a program and its tests are usually written over logical qubits, whereas execution depends on the physical qubits selected during compilation and deployment.
Figure 4. Qubit-characterization view. The diagram distinguishes logical and physical qubits and links qubit roles, states, representations, bases, and deployment-relevant physical attributes.
QSoftCore classifies logical qubits by QubitPurpose. A data qubit carries application or intermediate data, while an ancilla qubit supports auxiliary computation, state preparation, or measurement. The OCL constraint ConsistentAncillaPurpose requires an ancilla to have at least one AncillaFunction and prevents data qubits from having ancilla functions. Role-dependent expectations matter in testing: for example, a temporary-computation ancilla must return to a known state before reuse, while a measurement-support ancilla is measured to obtain test evidence through projective measurements [42] or runtime assertions [44]. A PhysicalQubit has a QubitTechnology and an availability value capturing deployment-relevant facts: a physical qubit may exist on a processor but be unavailable or unsuitable for a particular execution. Together with calibration and topology information (§ 2.6), these properties determine whether a compiled circuit can execute on a selected backend. Additional characteristics such as coherence, readout fidelity, and operation quality are not attributes of PhysicalQubit; they are recorded through the calibration context (§ 2.6), because QSoftCore focuses on SE-level deployment reasoning rather than detailed hardware characterization.
Qubit State and Basis View
Figure 4 shows the local state of an individual qubit. A QubitState represents the local state of an individual LogicalQubit, while QuantumSystemState (§ 2.5) represents the joint state of multiple qubits. This separation supports QSE tasks that require qubit-level expectations for initialization, ancilla reuse, measurement support, and local assertions: a single-qubit assertion refers to a QubitState, whereas a simulator snapshot, an entangled circuit state, or a test oracle checking joint-state properties refers to a QuantumSystemState.
QubitState inherits the pure/mixed distinction introduced for QuantumState. This distinction matters for local states because a qubit inside an entangled multi-qubit system may have a mixed local state even when the joint QuantumSystemState is pure, and because noise induces mixed states that testing must represent [46]. A QubitState can use three representation forms. A StateVectorRepresentation records a two-component vector and is valid when the local qubit state is pure. A DensityOperatorRepresentation records a density matrix and can express both pure and mixed local states, including reduced states arising from entanglement or noise. A BlochVectorRepresentation records a three-dimensional real vector for compact single-qubit visualization or assertion-style reasoning. These representations support local qubit-state expectations such as initialization conditions and runtime state assertions [42, 44].
QubitBasis specializes SystemBasis (§ 2.4.1), applying it to an individual QubitState rather than an entire quantum system. Basis choices affect measurement interpretation, test oracles, and debugging [10, 42]. For example, Pauli-string testing requires measuring each qubit in the Pauli eigenbasis corresponding to its operator (, , or ) [19], and projection-based assertions may require basis transformations to accommodate measurement-restricted hardware [11]. A BasisTransformation represents such a change of coordinates between qubit bases, realized through its operator attribute, a unitary operator.
Execution and Evolution View
Figure 5 refines the execution relation of Figure 1 to cover runtime evidence. A QCS is executed by a QuantumExecution, which is submitted to one QuantumBackend, carries an ExecutionStatusKind, instantiates a QuantumSystem, and may realize at most one QuantumEvolution and produce at most one ExecutionResult. Here, QuantumSystem denotes the logical, state-bearing system considered during that run, not the backend. In this view, each element plays a distinct role: the specification states the intended computation, the backend identifies where it is run, the quantum system defines the logical state being evolved, and the execution result records the raw evidence from that run. Derived estimates and error-mitigated results are represented separately.
Figure 5. Execution and evolution view. The diagram relates computation specifications to executions, sample counts, backends, logical quantum systems, evolution models, measurements, simulation outputs, and execution results, including derived estimates and mitigated results.
Quantum Execution
A QuantumExecution represents one concrete attempt to run a QCS. The class is needed because a specification can be executed repeatedly under different execution conditions, such as parameter bindings, sample count, backend choice, noise assumptions, solver settings, or run repetitions. The sampleCount attribute records how many repeated observations or runs are requested for that execution. Gate-based systems commonly call these repetitions shots, while quantum annealers call them reads. For example, the same gate-based circuit, annealing problem, or analog simulation specification may be evaluated in different execution environments or with different sampleCount values. These runs are not interchangeable evidence: QSE studies must record the execution context to interpret and reproduce results [47]. Quantum-optimization studies for SE similarly need to distinguish the formulated optimization problem from the solver or execution target used to evaluate it and report settings such as repetitions, shots, noise handling, baselines, and metrics [48, 49].
Each execution is submitted to one QuantumBackend and has an ExecutionStatusKind. QSoftCore distinguishes QPUBackend from SimulatorBackend, a distinction reflected in QSE testing studies that compare behavior across quantum software stacks and backend configurations [34, 40, 46]. The status values in Figure 5 record whether the job is submitted, queued, running, completed, failed, or cancelled. Together, backend and status provide the minimum context for monitoring, retry policies, failure diagnosis, and reproducibility records.
An execution may produce zero or one ExecutionResult, which may contain raw MeasurementRecord instances, each linked to the MeasurementOutcome it observes. Outcomes are possible results; records are observations. QSoftCore distinguishes three quantities. A Measurement is associated with a QuantumInstrument that specifies outcomes, probabilities, and state updates [13]; these probabilities give the expected distribution over MeasurementOutcomes. The observed OutcomeStatistic summarizes the records using a count or frequency. The inferred OutcomeEstimate records a derived estimate, such as an estimated probability and its uncertainty. An ErrorMitigationApplication applies an ErrorMitigationStrategy to raw execution evidence and produces a MitigatedResult alongside it, augmenting rather than replacing the raw observations. These distinctions support statistical testing, where counts, frequencies, and estimates are interpreted stochastically rather than as deterministic returns [15, 50]. Simulator-specific evidence is represented as a distinct subtype. A SimulationResult specializes ExecutionResult and may contain StateSnapshot instances. Each snapshot captures a QuantumSystemState at a selected point, such as a saved statevector for a circuit simulation or a sampled state representation for an analog simulation. Such snapshots are simulator-side artifacts, not ordinary measurement records: they should not be treated as directly observed intermediate states, since accessing an unknown quantum state generally requires additional measurement procedures [13].
Quantum Evolution
A QuantumEvolution describes how the QuantumSystemState of the logical QuantumSystem changes during an execution. An execution may realize zero or one explicitly represented QuantumEvolution; the zero case covers executions whose evolution is unavailable, such as failed jobs or runs that expose only final observations. QuantumSystemState is a joint state, not a list of independent local states. This matters for SE because tests, assertions, debugging evidence, and simulator snapshots may need to reason about joint-state properties rather than checking each local subsystem independently, especially when entanglement is involved [13, 15, 44]. The stateSamples association records selected states of an evolution, such as initial, intermediate, and final states. These samples are a finite engineering view for specification, simulation, testing, or visualization. They do not imply that continuous evolution is inherently discrete.
QSoftCore distinguishes ideal closed-system evolution from open-system evolution. UnitaryEvolution is described by a UnitaryOperator and captures reversible behavior, such as the ideal effect of a gate sequence before measurement or noise [13]. HamiltonianEvolution is a unitary subtype whose dynamics is generated by a HamiltonianModel; a ControlSchedule specifies time-varying controls for that model when needed (see § 2.3) [23, 24, 32]. OpenSystemEvolution is described by a QuantumChannel and covers evolution affected by measurement, reset, decoherence, amplitude damping, depolarizing noise, or other interaction with an environment [13].
The distinction is practical for QSE. Unitary reasoning supports equivalence checking, reversible-transformation reasoning, and statevector simulation. Open-system reasoning is needed whenever non-ideal effects influence the observed result, including timing effects. A transformation that is sound under ideal unitary semantics may not preserve behavior under open-system or noisy execution semantics. Explicit evolution kinds therefore help engineers choose suitable simulators, test oracles, equivalence relations, and debugging explanations [14, 15, 34].
Overall, this view separates the intended computation, the execution attempt, the modeled evolution of the logical system, and the evidence returned. This gives QSE methods traceability from design intent to runtime evidence: what was specified, where and whether it ran, how its evolution was modeled, and what observations were obtained.
Deployment View
Deployment concepts of QSoftCore can be divided into paradigm-neutral elements including deployment configurations and artifacts, backends, calibration profiles, and individual execution occurrences, and paradigm-specific ones. For gate-based systems these include compiled circuits, native operations, device topologies, and qubit mappings; for analog and annealing systems, device Hamiltonians, physical subsystems, interaction topologies, and variable mappings. These concepts affect feasibility, portability, reproducibility, and cost [51].
Figure 6. Gate-based deployment view. The diagram relates executions to deployment configurations, artifacts, backends, noise models, processor capabilities, calibration profiles, and qubit mappings.
Gate-Based Deployment
As shown in Figure 6, each QuantumExecution uses a DeploymentConfiguration, which identifies a DeploymentArtifact, a target QuantumBackend, and execution context such as compiler or transpiler settings, software development kit (SDK) version, selected calibration profile, and, for simulator runs, a SimulationConfiguration and optional NoiseModel. This separation makes repeated executions, alternative deployment choices, and their shared computation specification traceable [47].
QSoftCore distinguishes QPUBackend and SimulatorBackend because QSE studies show that backend choice, stack behavior, noise assumptions, and hardware constraints can affect testing evidence, feasibility assessment, and reproducibility [34, 40, 46, 51]. For QPU execution, the target backend provides access to a GateBasedQuantumProcessor. QSoftCore records only deployment-relevant information rather than low-level hardware behavior: ConnectivityTopology constrains which qubits can interact directly; NativeOperation identifies operations supported by the processor; and CalibrationProfile records time-varying information such as error rates, gate duration, readout quality, and coherence. Together, this information provides provenance for backend-dependent decisions.
A GateBasedDeploymentArtifact is the backend-specific realization of the QCS. It may contain a compiled circuit, resolved parameters, decompositions, scheduling information, and one or more QubitMapping instances. Because a processor supports only particular qubits and native operations, compilation may introduce routing operations such as SWAPs (state exchanges between qubits) or decompose unsupported logical operations. Each QubitMapping connects a LogicalQubit to a PhysicalQubit of the selected processor, making physical placement explicit. This matters because tests and analyses are usually expressed over logical qubits, whereas QPU behavior is conditioned by the selected processor, topology, calibration state, and mapped physical qubits [40, 46].
For simulator deployment, a SimulationConfiguration specifies whether execution uses ideal or noisy simulation and may configure the targeted SimulatorBackend. Ideal simulation supports reference results for testing and validation. Noisy simulation uses a NoiseModel to approximate selected deviations from ideal quantum evolution, such as operation errors, decoherence, state-preparation errors, or measurement errors [13]. A calibration profile may inform a NoiseModel, but QSoftCore keeps CalibrationProfile and NoiseModel separate because QSE often uses noise models as execution assumptions for testing, simulation, feasibility assessment, or result interpretation, not as complete device descriptions [34, 46, 47, 51]. A noise model can therefore be reused, simplified, or constructed independently of a particular calibration profile.
Overall, the gate-based deployment view links execution to its deployable artifact, target backend, physical mapping, calibration context, and simulation assumptions. QSE studies using gate-based algorithms, such as QAOA-based test case optimization, rely on backend-adapted circuits, parameter settings, and execution assumptions to interpret reported results [18]. Testing, platform, noise-mitigation, and reproducibility studies further show that backend identity, transpilation, noise assumptions, and execution settings affect runtime evidence and diagnosis [34, 40, 46, 47].
Analog and Quantum-Annealing Deployment
Figure 7 reuses the deployment concepts of the gate-based view and adds concepts specific to continuous evolution and device-level analog modeling. As in gate-based deployment, an AnalogDeploymentArtifact is the deployable analog realization, such as hardware-compatible Hamiltonian parameters and a control schedule. The following paragraphs first define the backend context to interpret this realization—the selected device Hamiltonian, physical subsystems, interaction topology, and calibration profile—and then describe the annealing-specific evolution terms and how they are mapped to physical resources.
Figure 7. Analog and quantum-annealing deployment view. The diagram extends deployment with analog artifacts, device Hamiltonians, physical subsystems, interaction topologies, calibration profiles, annealers, and variable mappings.
Device characterization. An AnalogQuantumProcessor is mainly characterized by a DeviceHamiltonian: a mathematical model of the fixed and controllable physical dynamics available for execution. This is the analog counterpart to the gate-based characterization described in § 2.6.1. A common parameterized form is:
where captures fixed device dynamics that are not directly controlled during execution; each , for the device’s supported control terms indexed by , is either a coupling between physical subsystems (an interaction term) or a locally driven term (a control term); and is the time-dependent control coefficient that scales that term. The formula characterizes the device in three ways: the fixed term , the set of terms the device can realize, and the admissible ranges and timing resolution of the control coefficients . The latter two are the tunable parameters of the device, not specification-level quantities. Deployment feasibility therefore depends on whether the requested dynamics fall within these characterized ranges and on which physical subsystems can participate in the required terms [20].
Physical subsystems and calibration. A DeviceHamiltonian acts on the PhysicalQuantumSubsystem instances owned by the processor; QSoftCore records this relation through actsOn. PhysicalQuantumSubsystem keeps the deployment view independent of qubit-only assumptions: a subsystem may be a qubit, qudit (a -level quantum system with ), bosonic mode (e.g., a photon or oscillator mode), fermionic mode (e.g., an occupied or unoccupied fermionic state), or another physical quantum unit. Its physical realization records the implementation technology, such as superconducting circuits, trapped ions, neutral atoms, photonic systems, or semiconductor spins. Similar to ConnectivityTopology in gate-based deployment, the processor’s InteractionTopology gives a graph view of which physical subsystems can interact; its SubsystemCoupling instances generalize gate-based QubitCoupling to non-qubit subsystems. This topology complements DeviceHamiltonian: the Hamiltonian gives the mathematical form of each interaction term, while the topology records which of those terms the selected processor can physically realize.
As in gate-based deployment, QSoftCore keeps CalibrationProfile as a reference to the time-specific device characterization used for execution, rather than modeling the profile’s internal fields. A deployment configuration selects one profile for execution, embedding, or feasibility assessment from the targeted backend’s calibration history, tying each run to a definite device state. As discussed for simulator deployment, a calibration profile may inform a NoiseModel, but the two serve different roles: the calibration profile identifies device evidence, while the noise model specifies how a simulator approximates non-ideal behavior.
Annealing Hamiltonians. A QuantumAnnealer specializes AnalogQuantumProcessor and uses physical qubits as its computational subsystems. With the device context established, annealing deployment turns to the computation: a logical problem Hamiltonian is mapped to physical qubits, combined with a driver Hamiltonian to form the requested evolution, and checked for realizability against the device Hamiltonian. Before deployment, an Ising energy model can be represented as the logical problem Hamiltonian
where and identify logical variables represented in QSoftCore by DecisionVariable instances. The coefficients score individual variable assignments, while scores pairwise compatibility or conflict between assignments [24, 27]. Together, these terms define the optimization landscape: assignments with lower energy represent better candidate solutions. Deployment must realize this logical Hamiltonian using the selected processor’s physical qubits, supported couplings, and coefficient ranges, yielding the mapped Hamiltonian . A typical forward-annealing evolution combines with a driver term:
where the parameter is the ControlSchedule’s progress parameter (Figure 5), not a DecisionVariable, and runs from 0 at the beginning of the anneal to 1 at its end. The functions and set the relative weights of the two terms: weights the driver Hamiltonian, which helps the system explore candidate assignments, while weights the problem Hamiltonian, whose low-energy states correspond to better solutions. A common driver applies a Pauli-X operator to each logical variable, , where ranges over the same logical variables. This driver acts in the Pauli-X basis, while is expressed in the Pauli-Z basis: because Pauli-X terms flip or mix candidate assignments they support exploration, whereas Pauli-Z terms assign energies to those assignments so that lower-energy states represent better solutions.
As characterized above, describes what the selected processor can physically realize. Deployment checks whether and can each be expressed as linear combinations of the device’s available operators , and whether the schedule functions and can be realized by time-dependent settings of the control coefficients . Constant factors and signs may differ between hardware and mathematical conventions.
Annealing variable mapping and embedding. An AnnealingDeploymentArtifact specializes AnalogDeploymentArtifact and records how the logical problem’s DecisionVariable instances are assigned to physical resources through one or more VariableMapping instances, each mapping one DecisionVariable to one or more PhysicalQubit instances. When the selected annealer’s InteractionTopology supports every nonzero interaction, each variable maps to a single physical qubit; otherwise it requires a connected set of qubits, commonly called minor embedding [27]. A valid mapping uses only physical qubits of the selected annealer, keeps the qubit sets of distinct variables disjoint, keeps each multi-qubit representation connected through SubsystemCoupling instances, and preserves each nonzero through a supported coupling.
Beyond enabling structural feasibility checks before execution, these mappings are QSE-relevant because they affect resource estimates, execution reproducibility, and interpretation of sampled results. Mapping one DecisionVariable to multiple PhysicalQubit instances consumes additional physical qubits and introduces internal couplings. Coefficients and that exceed the processor’s supported range must be scaled down, which shrinks the energy differences between candidate solutions and makes the annealer more sensitive to noise. Consequently, embedding quality can affect whether a deployment fits the backend and how robust the sampled solutions are [27, 52].
Overall, this view records what QSE needs to know to deploy analog and annealing computations. QSE deployment and reproducibility work treats backend identity, cloud execution, sample-count settings, compiler or SDK versions, calibration time, noise assumptions, and execution configuration as engineering context rather than incidental runtime detail [2, 47, 51]. For annealing-oriented QSE, QUBO, Ising, and problem-Hamiltonian formulations already appear as software artifacts for test optimization, benchmarking, annealer execution, and program analysis [9, 30, 31, 48, 49]. The analog-specific concepts in this view extend that deployment framing by making device dynamics, subsystem couplings, and variable-to-qubit mappings explicit.
Application Examples
As a representative embodied-AI case, consider the hybrid quantum deep-reinforcement-learning TurtleBot navigation workflow studied by Hohenfeld et al. [53]. The navigation application is an Application and hence a SoftwareSystem: classical ClassicalComponent instances encode sensor observations, maintain the navigation state, and execute the selected actions, while the simulated environment’s physics engine detects collisions. Its Requirement instances include reaching the target while avoiding obstacles, together with limits on control-loop latency, training or execution cost, and acceptable failure probability. The navigation task is a ComputationalProblem with ProblemKind::decision, since the deliverable is an action choice. An AlgorithmConfiguration links that problem and its requirements to a QuantumAlgorithm: a hybrid reinforcement-learning method in which a parameterized quantum circuit (PQC) approximates the action-value (Q) function. The configuration is implemented by a QuantumProgram, a SoftwareComponent, that encodes each observation, binds its values to circuit parameters, and constructs a gate-based QCS represented by a GateBasedComputation containing a QuantumCircuit. The circuit applies operations to LogicalQubit instances and measures the resulting state to provide action values to the classical learning loop, which updates the PQC parameters.
For execution and deployment, a DeploymentConfiguration selects a GateBasedDeploymentArtifact, a QuantumBackend of type SimulatorBackend, and a SimulationConfiguration; an optional NoiseModel records non-ideal simulation assumptions. TensorFlow Quantum with Cirq/Qsim provides the quantum-side simulator, while PyBullet supplies the external embodied-navigation environment. At each step of an evaluation episode, the current observation induces a QuantumExecution with a recorded sampleCount; the execution instantiates a QuantumSystem and returns an ExecutionResult containing MeasurementRecord instances. A classical component decodes these records into a motion command and sends it to the simulated robot, which executes it and detects collisions. The resulting state transition supplies the next input and repeats the loop. This mapping keeps the reusable program, gate-level specification, simulator deployment, runtime evidence, and classical control boundary distinct, and it makes clear that the case provides simulator-based embodied evaluation rather than physical-QPU evidence.
Consider also a hybrid test-suite optimization application which addresses the SE problem of selecting a small test-case subset while preserving coverage. Its requirements specify the desired selection behavior and constrain quantum-specific feasibility and quality attributes, including cost, available qubits, circuit depth, backend access, execution budget, and acceptable failure probability. The application owns a ComputationalProblem with ProblemKind::optimization. These requirements constrain an AlgorithmConfiguration that selects QAOA, a QuantumAlgorithm using variational and HamiltonianEvolution techniques. The configuration is implemented by a QuantumProgram, a SoftwareComponent of the application, alongside a ClassicalComponent that prepares inputs and checks coverage.
The QuantumProgram constructs a QCS realized as a GateBasedComputation containing a QuantumCircuit. Its StatePreparation, Gate, and Measurement operations act on LogicalQubit instances and realize the QAOA cost and mixer Hamiltonians referenced via computationHamiltonians. A DeploymentConfiguration selects a GateBasedDeploymentArtifact with QubitMapping instances, a QuantumBackend, calibration, and noise context. A QuantumExecution runs the artifact with a sampleCount and returns an ExecutionResult containing MeasurementRecord instances; the classical component interprets these records as candidate subsets and checks them against the requirements. The same problem may use a QuantumAnnealingComputation over an EnergyModel, showing ProblemKind does not determine the paradigm [9, 18].
Assessment of QSoftCore for QSE
This section assesses whether QSoftCore provides the QC foundation the QSE activities require. It does not ask whether QSoftCore replaces those activities. We organize the literature into three groups by their role in the assessment, rather than by an exhaustive taxonomy of QSE research. 1) High-level summaries and reviews: QSE surveys, roadmaps, and lifecycle studies, e.g., [1, 2, 3, 4], identify the relevant activity space to establish which SE tasks the assessment must cover. 2) Overall organization and structure: requirements, architecture, and modeling studies, e.g., [5, 37, 38, 54, 55, 56], expose the SE–QC bridge at the level of artifacts and decisions, and show how application needs, system structures, and development models refer to QC concepts. 3) Fine-grained QSE phases and goals: studies of testing, debugging, runtime behavior, reproducibility, and maintenance, e.g., [14, 15, 34, 40, 42, 47], provide operational evidence that helps identify the QC concepts QSE activities must expose when artifacts are executed, evaluated, and evolved.
Together, these groups define an assessment chain from the QSE task scope, through the SE–QC bridge, to the runtime and maintenance evidence that the foundation should support. The unit of analysis is therefore one QSE task and its required SE–QC bridge. Accordingly, QC concepts required by a task should be represented in QSoftCore, while task-specific artifacts and procedures, such as test cases, test oracles, defect reports, change requests, evaluation metrics, and process activities, remain in a separate QSE activity layer that uses QSoftCore as its QC vocabulary. Symmetrically, when a QC concept already represented in QSoftCore is only weakly addressed by current QSE studies, we interpret this as an underdeveloped part of the activity layer rather than evidence that the conceptual foundation is incomplete.
The following subsections apply this assessment logic to the QSE activities in which SE artifacts and decisions should be connected to QC-specific assumptions, computations, execution evidence, and deployment context.
Requirements
Requirements engineering elicits, analyzes, specifies, validates, and manages stakeholder needs and constraints for an intended system. In QSE, it is essential because the suitability of a computational problem for QC, the allocation between classical and quantum computation, and feasibility under hardware constraints should be understood before algorithm, circuit, and backend decisions are made.
In the literature, Saraiva et al. [57] argued the importance of hardware-related non-functional requirements, including limits on qubit count, circuit depth, qubit connectivity, and ancilla-qubit overhead. Yue et al. [5] distinguished quantum, classical, and hybrid requirements, connected application needs to quantum-algorithm selection, and identified gate and ancilla-qubit estimates, qubit and circuit-depth limits, and hardware-error-related reliability concerns. Stein et al. [6] additionally noted that an application may involve heterogeneous computing resources, e.g., CPU, GPU, and QPU. In QSoftCore, all these aspects are represented by SoftwareSystem, Application, Requirement, QuantumProgram, QuantumAlgorithm, QuantumCircuit, Qubit, QubitPurpose, and QPUBackend.
However, we observe that the quantum requirements engineering literature usually starts from gate-based programs and circuits. It recognizes hardware constraints but does not systematically represent the ComputationalProblem, the composition and development of a quantum application, or the choice among computation paradigms. Our position is that requirements engineering should first establish the computational problem, applicable quantum algorithms or techniques, candidate QCS paradigms, and relevant backend characteristics, before committing to a realization. For gate-based computation, this means going beyond circuit depth, width (qubit count), and gate counts: requirements should distinguish LogicalQubit demand from PhysicalQubit availability and constrain connectivity, calibration profiles, noise models, and backend mappings. QSoftCore supplies these concepts.
Architecture Design
Architecture design structures a software system and selects technologies through which it realizes its requirements. Modeling notations, tools, and methodologies support engineers in representing, analyzing, communicating, and making these decisions for quantum applications.
More than a decade ago, Wecker and Svore [58] recognized the need to raise the abstraction level above quantum physics and linear algebra when designing quantum algorithms. provides this support through a domain-specific language, while its abstractions remain centered on qubits, gates, circuits, and operations for programming, compilation, and simulation. Notably, the work explicitly addresses both gate-based and adiabatic QC; its implementation nevertheless focuses on gate-based QC.
The work by Ali and Yue [59] is an early effort to understand quantum programs from an SE perspective. The authors proposed to use the UML state machine notation as a high-level description of program execution. One noticeable limitation concerns the very restricted definition of State itself, which omits the measurement basis and represents quantum states primarily through computational-basis outcome probabilities. QuanUML [56] extends UML class and sequence diagram notations with QC concepts, including qubits, gates, and inter-qubit messages. Its aim is to specify quantum algorithms at low level and generate quantum programs automatically [38]. However, on the notation side, representing gates as messages exchanged between qubits can be misleading. For instance, a CNOT gate is one joint operation with control and target operands, not two messages sent between the participating qubits. Q-UML [55] is another UML-based notation for specifying quantum algorithms. It extends UML graphical notations to distinguish quantum from classical elements, aiming to facilitate the understanding of an algorithm’s high-level logic and classical–quantum workflow. However, some Q-UML constructs can suggest that quantum states and operations are ordinary values or messages that can be directly set, retrieved, or exchanged. On actual quantum hardware, programs manipulate qubits through quantum operations and obtain classical information through measurement, and arbitrary internal states are not directly readable.
In the literature, gate-based QC, typically expressed as quantum circuits, is usually taken as the default. Current modeling notations remain limited in scope and largely low-level: they primarily describe quantum-algorithm and circuit elements, with little support for quantum-application design, computation-paradigm selection, or deployment-architecture design. Raising the level of abstraction, particularly through UML-based notations, is valuable; however, these notations must preserve QC semantics rather than recast quantum states, operations, or measurements as ordinary classical objects or messages.
QSoftCore retains the literature’s core QC concepts—software systems and components, quantum programs and algorithms, circuits, operations, qubits, mappings, compiled circuits, and backends—but adds end-to-end design reasoning. It links Application, SoftwareSystem, Requirement, and ComputationalProblem to a selected QuantumAlgorithm through an AlgorithmConfiguration, which is realized by a paradigm-specific QCS. This QCS may be a GateBasedComputation with a QuantumCircuit, a QuantumAnnealingComputation with an EnergyModel, an AnalogComputation with a HamiltonianModel and ControlSchedule, or a MeasurementBasedComputation with a MeasurementPattern, subject to problem, requirements, backend, and deployment constraints. QSoftCore therefore supplies the QC concepts that architecture-design artifacts can reference, including the application, paradigm, and deployment concerns largely absent from the reviewed literature. It intentionally leaves generic architectural constructs—components, interfaces, connectors, and decisions—to UML, ADLs, and established SE methods, so that concrete notations can combine these constructs with QSoftCore’s QC concepts.
Code Generation
Quantum program generation realizes the decisions made during requirements and architecture design as executable quantum and hybrid software. This subsection considers the transformations from requirements and design models to quantum programs, paradigm-specific specifications, and backend-adapted artifacts, and the QC concepts that these transformations must preserve.
M2QCode [38] generates quantum programs from low-level UML models, while Jiménez-Navajas et al. [60] proposed to generate Python-Qiskit artifacts for hybrid quantum-classical software systems modeled in Q-UML [55]. Gemeinhardt et al. [61] supported compositional circuit design and automated code generation through composite quantum gates for circuit reuse and a loop operation for control flow. All three approaches target gate-based circuits and use abstractions close to programming, such as qubits, gates, circuits, and control-flow constructs. They therefore support transformations from low-level design models to quantum programs, but provide limited support for higher-level application design or reasoning about alternative computation paradigms. QuantME [62] generates executable hybrid workflow artifacts from quantum-enhanced process models. Unlike circuit-code generators, it focuses on orchestrating and deploying a quantum application, which we discuss in § 3.4. Emerging LLM-based work explores generation at different levels. Siavashe and Moin [63] proposed to generate Qiskit code from UML models using retrieval-augmented generation, whereas QAgent [64] autonomously generates OpenQASM programs. QPipe [65] is an LLM-based multi-agent system that operates at the application level by translating natural-language optimization requirements into executable quantum applications with traceable artifacts for requirement parsing, formulation, code generation, review, execution, and verification.
QSoftCore covers most QC concepts used in the above literature, including quantum programs, circuits, operations, qubits, registers, parameters, and compiled circuits. Gemeinhardt et al.’s composite gates and loop operation [61] suggest two concepts that QSoftCore does not adopt. QSoftCore does not introduce a separate CompositeQuantumOperation, because operation composition is represented at the circuit level through ordered OperationApplication instances that invoke QuantumOperation definitions; nor does it model loops, which are implementation-level control-flow constructs expressible in a programming or behavioral notation rather than as QC concepts. Moreover, QSoftCore covers multiple QC paradigms rather than only gate-based circuits and represents quantum systems, states, deployment, execution, and evolution. For code generation, DeploymentConfiguration provides target-specific information for compilation and backend selection, and QuantumState, StatePreparation, Gate, and Measurement guide the generation and validation of state preparation, transformation, and measurement instructions.
Execution and Deployment
Execution and deployment make generated quantum and hybrid artifacts operational by binding them to executable workflows, service interfaces, backend-specific deployment artifacts, and runtime evidence.
QPipe [65], discussed above, also executes and verifies the applications it generates. QuantME [62] specifies hybrid quantum circuit-based workflows and transforms them into executable workflow artifacts. Its workflows refer to QC concepts such as QuantumCircuit, NoiseModel, DeploymentConfiguration, QPUBackend, QuantumExecution, and ExecutionResult, while generic workflow constructs remain the responsibility of established workflow and SE notations. Follow-up work further distinguishes application-workflow orchestration from deployment orchestration [66]; QC patterns can also automate the construction and adaptation of hybrid workflows [67].
As already discussed in § 3.1 and § 3.2, some execution and deployment decisions need to be made in earlier QSE activities. However, the literature remains largely circuit-based, with other QC paradigms insufficiently covered. QSoftCore makes an initial effort to conceptually connect Requirement and Application to an AlgorithmConfiguration and paradigm-specific QCS, and then to DeploymentConfiguration, QuantumBackend, QuantumExecution, and ExecutionResult across paradigms. These links support feedback across QSE activities. Generated code, compilation, workflow adaptation, or backend assessment may reveal constraints that require revised requirements or design decisions [2, 4, 51]. Furthermore, as shown in Figure 5, ExecutionResult records raw evidence, while ErrorMitigationApplication applies an ErrorMitigationStrategy and produces a separate MitigatedResult. Comparing the two helps assess noise effects and mitigation effectiveness [46]. QSoftCore also records the QC-specific sampleCount of a QuantumExecution; broader study-level measures, such as independent experimental repetitions, remain outside its scope [49].
Quality Assurance
Quality assurance activities, including testing, verification, and debugging, are much more mature than other SE activities in the QSE literature. Quantum software testing (QST) is the field that provides the richest body of empirical evidence such as mutation testing (Muskit) [39], metamorphic testing (MorphQ) [40], combinatorial testing (QuCAT) [68], differential testing (QDiff) [34], statistical and projective-measurement testing [42, 50], runtime assertion checking (ProQ and Rovara et al.) [11, 44], static analysis (LintQ) [41], and bug benchmarks (Bugs4Q) [12]. Recent methodological analysis further reports that empirical QST studies vary substantially in their programs under test, inputs, oracles, baselines, shot configurations, execution repetitions, backend choices, and artifact support [69].
Despite this maturity, the QST literature is predominantly gate-based and circuit-centered. This emphasis appears in both the program representations and platforms used by existing techniques, with substantial reliance on Qiskit and gate-model programs [14, 15]. Consequently, the reviewed evidence is strongest for gate-based programs, while testing, verification, and debugging for analog, annealing, and measurement-based paradigms remain less developed. The literature also does not yet provide a general testing solution for hybrid quantum applications or sufficiently bridge the interpretation of results obtained from simulator and QPU backends. These gaps identify areas that QSoftCore can help address: QSoftCore relates these testing concerns to QC concepts across its operation, qubit, state, execution and evolution, and deployment views. A gate-based program or circuit under test can refer to QuantumProgram, QuantumCircuit, OperationApplication, ParameterBinding, Measurement, Reset, and OperationContract. Test inputs and expected states or properties can refer to LogicalQubit, QuantumState, QuantumSystemState, and SystemBasis. Test execution and evidence can refer to QuantumExecution, sampleCount, ExecutionResult, MeasurementRecord, MeasurementOutcome, NoiseModel, QuantumBackend, CalibrationProfile, and DeploymentConfiguration. These concepts allow QSoftCore to express test oracles for non-gate paradigms in terms of intended evolution, observables, and outcome distributions, complementing gate-sequence oracles. More generally, linking the specification under test, the computation being executed, the measurement evidence, and the backend or noise assumptions makes QST results interpretable and supports diagnosis.
Li et al.’s ProQ [11] expresses quantum-state properties as predicates over selected quantum variables and checks them through projective measurements, with transformations that make the predicates executable under measurement restrictions. Rovara et al. [44] define equality and superposition assertions and propose an automated framework that translates them into measurements, splits programs into executable slices for multiple assertions, reduces evaluation overhead, and evaluates the outcomes under noise on real quantum computers. More generally, QSoftCore represents assertion specifications as properties over an expected QuantumState or QuantumSystemState associated with selected LogicalQubits or a QuantumRegister. Assertions may be associated with selected points in a QuantumEvolution or QuantumExecution, with evidence represented by simulator-specific StateSnapshotS or by hardware ExecutionResultS and measurement records. These assertion works are again gate-based. Future runtime assertions for analog quantum computations can build on QSoftCore’s QuantumEvolution, HamiltonianModel, DeviceHamiltonian, state, and execution concepts to constrain observables, energy values, state overlap, or outcome distributions during or after Hamiltonian evolution.
Debugging work locates and explains faults after observing anomalous behavior. Sato et al. [50] divided a quantum program into segments and used cost-based search, early determination, finalization, and lookback strategies to localize faults under the cost and statistical constraints of repeated quantum executions. QDiff [34] generates semantically equivalent circuit variants, filters them by circuit and hardware characteristics, and compares their outcome distributions on simulators and QPUs to expose software-stack instabilities. Bugs4Q [12] provides manually validated and reproducible Qiskit bugs with buggy/fixed versions and reproducing tests for controlled debugging studies. The QC concepts used by these works, including QCS, QuantumCircuit, OperationApplication, CompiledCircuit, QuantumExecution, sampleCount, QuantumBackend, ExecutionResult, and MeasurementOutcome, are covered by QSoftCore. QSoftCore additionally supports non-gate debugging through HamiltonianModel, ControlSchedule, QuantumEvolution, and observable-based evidence, and represents raw versus mitigated results through ErrorMitigationApplication, ErrorMitigationStrategy, and MitigatedResult. The debugging literature covers search procedures, diagnoses, and bug benchmarks, which remain SE debugging artifacts rather than core QC concepts, and are hence not covered by QSoftCore.
Conclusion
Quantum software engineering (QSE) needs a precise account of quantum computing concepts that supports software engineering decisions and evidence. We introduced QSoftCore, a conceptual model that distinguishes applications, algorithms, programs, computation specifications, executions, and deployment artifacts. Our assessment shows that current QSE work is largely gate-based, circuit-centered, and close to programming-level abstractions, with limited support for application design, alternative paradigms, hybrid applications, deployment reasoning, and interpreting simulator and hardware results. QSoftCore covers the QC concepts these works use and extends them with explicit representations for alternative paradigms, quantum evolution, deployment context, execution evidence, and raw versus mitigated results. It therefore provides the QC foundation QSE activities can reference without replacing established SE methods, and remains incomplete by design, to evolve with QC technologies and QSE practices.
Acknowledgment
This work is supported by the fundamental research funds for the central universities.
References
- [1]M. Piattini and J. M. Murillo, “Quantum software engineering landscape and challenges,” in Quantum Software Engineering. Springer, 2022, pp. 25–38.DOI
- [2]B. Weder, J. Barzen, F. Leymann, and D. Vietz, “Quantum software development lifecycle,” in Quantum Software Engineering. Springer, 2022, pp. 61–83.arxiv.org/abs/2106.09323
- [3]K. Dwivedi, M. Haghparast, and T. Mikkonen, “Quantum software engineering and quantum software development lifecycle: a survey,” Cluster Computing, vol. 27, pp. 7127–7145, 2024.DOI
- [4]J. M. Murillo, J. García-Alonso, E. Moguel, J. Barzen, F. Leymann, S. Ali, T. Yue, P. Arcaini, R. Pérez-Castillo, I. G.-R. de Guzmán, M. Piattini, A. Ruiz-Cortés, A. Brogi, J. Zhao, A. Miranskyy, and M. Wimmer, “Quantum software engineering: Roadmap and challenges ahead,” ACM Transactions on Software Engineering and Methodology, vol. 34, no. 5, 2025.DOI
- [5]T. Yue, S. Ali, and P. Arcaini, “Towards quantum software requirements engineering,” in 2023 IEEE International Conference on Quantum Computing and Engineering (QCE), 2023.arxiv.org/abs/2309.13358
- [6]H. Stein, S. Schröder, P. Kienast, and M. Kulig, “Towards requirements engineering for quantum computing applications in manufacturing,” in Proceedings of the 57th Hawaii International Conference on System Sciences, 2024, pp. 7614–7621. [Online]. Available: https://hdl.handle.net/10125/107301
- [7]A. Ahmad, A. B. Altamimi, and J. Aqib, “A reference architecture for quantum computing as a service,” Journal of King Saud University - Computer and Information Sciences, vol. 36, p. 102094, 2024.
- [8]M. S. Aktar, P. Liang, M. Waseem, A. Tahir, A. Ahmad, B. Zhang, and Z. Li, “Architecture decisions in quantum software systems: An empirical study on stack exchange and github,” Information and Software Technology, vol. 177, p. 107587, 2025.arxiv.org/abs/2312.05421
- [9]X. Wang, A. Muquet, T. Yue, S. Ali, and P. Arcaini, “Test case minimization with quantum annealers,” ACM Transactions on Software Engineering and Methodology, 2024.DOI
- [10]Y. Li, K.-Y. Cai, and B. Yin, “A dynamic test oracle for quantum programs with separable output states,” IEEE Transactions on Software Engineering, vol. 52, no. 4, pp. 1568–1591, 2026.DOI
- [11]G. Li, L. Zhou, N. Yu, Y. Ding, M. Ying, and Y. Xie, “Projection-based runtime assertions for testing and debugging quantum programs,” Proceedings of the ACM on Programming Languages, vol. 4, no. OOPSLA, pp. 1–29, 2020.DOI
- [12]P. Zhao, Z. Miao, S. Lan, and J. Zhao, “Bugs4q: A benchmark of existing bugs to enable controlled testing and debugging studies for quantum programs,” Journal of Systems and Software, 2023.DOI
- [13]M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information, 10th ed. Cambridge University Press, 2010.
- [14]A. G. de la Barrera, I. G.-R. de Guzmán, M. Polo, and M. Piattini, “Quantum software testing: State of the art,” Journal of Software: Evolution and Process, vol. 35, no. 4, p. e2419, 2023.
- [15]D. Fortunato, L. Jiménez-Navajas, J. Campos, and R. Abreu, “Verification and validation of quantum software,” in Quantum Software: Aspects of Theory and System Design. Springer, 2024, pp. 93–123.DOI
- [16]D. Eichhorn, T. Pett, T. Osborne, and I. Schaefer, “Quantum computing for feature model analysis,” in Proceedings of the 27th ACM International Systems and Software Product Line Conference, 2023.DOI
- [17]R. J. Hall, “A quantum algorithm for software engineering search,” in 2009 IEEE/ACM International Conference on Automated Software Engineering, 2009.DOI
- [18]X. Wang, S. Ali, T. Yue, and P. Arcaini, “Quantum approximate optimization algorithm for test case optimization,” IEEE Transactions on Software Engineering, 2024.DOI
- [19]A. Muqet, S. Ali, and P. Arcaini, “Quantum program testing through commuting pauli strings on ibm’s quantum computers,” in Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering, 2024, pp. 2130–2141.
- [20]Y. Peng, J. Young, P. Liu, and X. Wu, “SimuQ: A framework for programming quantum hamiltonian simulation with analog compilation,” Proceedings of the ACM on Programming Languages, vol. 8, no. POPL, 2024.DOI
- [21]X. Wang, Q. Xu, P. Arcaini, S. Ali, and T. Peyrucain, “Quantum machine learning-based test oracle for autonomous mobile robots,” 2025. [Online]. Available: https://arxiv.org/abs/2508.02407
- [22]A. Montanaro, “Quantum algorithms: An overview,” npj Quantum Information, vol. 2, 2016.DOI
- [23]S. Lloyd, “Universal quantum simulators,” Science, vol. 273, no. 5278, pp. 1073–1078, 1996.
- [24]T. Kadowaki and H. Nishimori, “Quantum annealing in the transverse Ising model,” Physical Review E, vol. 58, no. 5, pp. 5355–5363, 1998.DOI
- [25]R. Raussendorf and H. J. Briegel, “A one-way quantum computer,” Physical Review Letters, vol. 86, no. 22, pp. 5188–5191, 2001.
- [26]IBM Quantum, “Introduction to qiskit and ibm quantum,” https://quantum.cloud.ibm.com/docs/en/guides, accessed: 2026-08-11.
- [27]D-Wave Quantum, “D-wave documentation: Quantum annealing and qubo/ising models,” https://docs.dwavequantum.com/en/latest/, accessed: 2026-08-11.
- [28]Amazon Web Services, “Hello ahs: Run your first analog hamiltonian simulation,” https://docs.aws.amazon.com/braket/latest/developerguide/braket-get-started-hello-ahs.html, accessed: 2026-08-11.
- [29]Xanadu, “Photonics,” https://www.xanadu.ai/photonics/, accessed: 2026-08-11.
- [30]Y. Yang, M. Zhang, and T. Yue, “Ising-based test optimization and benchmarking,” in 2026 IEEE Conference on Software Testing, Verification and Validation (ICST), Testing Tools and Data Showcase, 2026. [Online]. Available: https://ieeexplore.ieee.org/document/11600467
- [31]R. Pérez-Castillo, L. Jiménez-Navajas, and M. Piattini, “Dynamic analysis of quantum annealing programs,” Journal of Systems and Software, vol. 201, p. 111683, 2023.
- [32]E. Farhi, J. Goldstone, S. Gutmann, J. Lapan, A. Lundgren, and D. Preda, “A quantum adiabatic evolution algorithm applied to random instances of an np-complete problem,” Science, vol. 292, no. 5516, pp. 472–475, 2001.DOI
- [33]B. Li, S. Ahmed, S. Saroogi, N. Lambert, F. Nori, A. Pitchford, and N. Shammah, “Pulse-level noisy quantum circuits with QuTiP,” Quantum, vol. 6, p. 630, 2022.DOI
- [34]J. Wang, Q. Zhang, G. H. Xu, and M. Kim, “Qdiff: Differential testing of quantum software stacks,” in 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE), 2021.DOI
- [35]P. Walther, K. J. Resch, T. Rudolph, E. Schenck, H. Weinfurter, V. Vedral, M. Aspelmeyer, and A. Zeilinger, “Experimental one-way quantum computing,” Nature, vol. 434, no. 7030, pp. 169–176, 2005.DOI
- [36]B. P. Lanyon, P. Jurcevic, M. Zwerger, C. Hempel, E. A. Martinez, W. Dür, H. J. Briegel, R. Blatt, and C. F. Roos, “Measurement-based quantum computation with trapped ions,” Physical Review Letters, vol. 111, no. 21, p. 210501, 2013.DOI
- [37]F. Gemeinhardt, A. Garmendia, and M. Wimmer, “Towards model-driven quantum software engineering,” in 2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE), 2021.DOI
- [38]X. Guo, S. Saito, and J. Zhao, “M2qcode: A model-driven framework for generating multi-platform quantum programs,” in 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE), 2025.arxiv.org/abs/2510.17110
- [39]E. Mendiluze, S. Ali, P. Arcaini, and T. Yue, “Muskit: A mutation analysis tool for quantum software testing,” in 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE), 2021.
- [40]M. Paltenghi and M. Pradel, “MorphQ: Metamorphic testing of the qiskit quantum computing platform,” in 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), 2023.DOI
- [41]———, “Analyzing quantum programs with lintq: A static analysis framework for qiskit,” Proceedings of the ACM on Software Engineering, 2024.DOI
- [42]N. H. Oldfield, C. Laaber, T. Yue, and S. Ali, “Faster and better quantum software testing through specification reduction and projective measurements,” ACM Transactions on Software Engineering and Methodology, vol. 34, no. 7, pp. 1–39, 2025.arxiv.org/abs/2405.15450
- [43]A. W. Cross, A. Javadi-Abhari, T. Alexander, N. de Beaudrap, L. S. Bishop, S. Heidel, C. A. Ryan, P. Sivaraiah, J. Smolin, J. M. Gambetta, and B. R. Johnson, “OpenQASM 3: A broader and deeper quantum assembly language,” ACM Transactions on Quantum Computing, vol. 3, no. 3, pp. 1–50, 2022.DOI
- [44]D. Rovara, L. Burgholzer, and R. Wille, “A framework for the efficient evaluation of runtime assertions on quantum computers,” 2025.arxiv.org/abs/2505.03885
- [45]N. Ma, J. Zhao, F. Khomh, S. Ali, and H. Li, “Qmon: Monitoring the execution of quantum circuits with mid-circuit measurement and reset,” 2025.arxiv.org/abs/2512.13422
- [46]A. Muqeet, T. Yue, S. Ali, and P. Arcaini, “Mitigating noise in quantum software testing using machine learning,” IEEE Transactions on Software Engineering, 2024.arxiv.org/abs/2306.16992
- [47]W. Mauerer and S. Scherzinger, “1-2-3 reproducibility for quantum software experiments,” in 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), 2022.arxiv.org/abs/2201.12031
- [48]M. Zhang, Y. Li, T. Yue, and K.-Y. Cai, “Quantum optimization for software engineering: A survey,” ACM Transactions on Software Engineering and Methodology, May 2026, just Accepted. [Online]. Available: https://doi.org/10.1145/3816147
- [49]———, “Empirical studies on quantum optimization for software engineering: A systematic analysis,” 2025. [Online]. Available: https://arxiv.org/abs/2510.27113
- [50]N. Sato and R. Katsube, “Bug-locating method based on statistical testing for quantum programs,” IEEE Transactions on Software Engineering, 2025.arxiv.org/abs/2409.20011
- [51]T. Yue and M. Zhang, “Q-READY: Predictive feasibility assessment for hybrid quantum-classical applications,” arXiv preprint arXiv:2606.16201, 2026.arxiv.org/abs/2606.16201
- [52]V. Choi, “Minor-embedding in adiabatic quantum computation: I. the parameter setting problem,” Quantum Information Processing, vol. 7, no. 5, pp. 193–209, 2008.arxiv.org/abs/0804.4884
- [53]H. Hohenfeld, D. Heimann, F. Wiebe, and F. Kirchner, “Quantum deep reinforcement learning for robot navigation tasks,” IEEE Access, 2024. [Online]. Available: https://ieeexplore.ieee.org/abstract/document/10568148DOI
- [54]A. A. Khan, A. Ahmad, M. Waseem, P. Liang, M. Fahmideh, T. Mikkonen, and P. Abrahamsson, “Software architecture for quantum computing systems—a systematic review,” Journal of Systems and Software, vol. 201, p. 111682, 2023.
- [55]C. A. Pérez-Delgado, “A quantum software modeling language,” in Quantum Software Engineering. Springer, 2022, pp. 103–119.
- [56]X. Guo, S. Saito, and J. Zhao, “Quantum: Towards a modeling language for model-driven quantum software development,” in 2025 IEEE 49th Annual Computers, Software, and Applications Conference (COMPSAC), 2025.
- [57]L. Saraiva, E. H. Haeusler, V. Costa, and M. Kalinowski, “Non-functional requirements for quantum programs,” in Proceedings of the 2nd Quantum Software Engineering and Technology Workshop, 2021, pp. 89–100.
- [58]D. Wecker and K. M. Svore, “LIQUi|>: A software design architecture and domain-specific language for quantum computing,” 2014. [Online]. Available: https://arxiv.org/abs/1402.4467
- [59]S. Ali and T. Yue, “Modeling quantum programs: Challenges, initial results, and research directions,” in Proceedings of the 1st ACM SIGSOFT International Workshop on Architectures and Paradigms for Engineering Quantum Software, 2020.DOI
- [60]L. Jiménez-Navajas, R. Pérez-Castillo, and M. Piattini, “Code generation for classical-quantum software systems modeled in UML,” Software and Systems Modeling, 2025.
- [61]F. Gemeinhardt, A. Garmendia, M. Wimmer, and R. Wille, “A model-driven framework for composition-based quantum circuit design,” ACM Transactions on Quantum Computing, vol. 5, no. 4, 2024.DOI
- [62]B. Weder, U. Breitenbücher, F. Leymann, and K. Wild, “Integrating quantum computing into workflow modeling and execution,” in 2020 IEEE/ACM 13th International Conference on Utility and Cloud Computing (UCC). IEEE Computer Society, 2020, pp. 279–291.
- [63]N. Siavash and A. Moin, “Model-driven quantum code generation using large language models and retrieval-augmented generation,” in Proceedings of the 28th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, 2025.
- [64]Z. Fu, F. Chen, and L. Jiang, “QAgent: An LLM-based multi-agent system for autonomous OpenQASM programming,” arXiv preprint arXiv:2508.20134, 2025.
- [65]M. Tao, Y. Li, T. Yue, M. Zhang, and A. A. Marcos, “Leveraging llm-based agentic systems to generate quantum applications for test optimization,” arXiv preprint arXiv:2607.00939, 2026.
- [66]B. Weder, J. Barzen, F. Leymann, and M. Zimmermann, “Hybrid quantum applications need two orchestrations in superposition: A software architecture perspective,” in 2021 IEEE International Conference on Web Services (ICWS). IEEE, 2021, pp. 1–13.
- [67]M. Beisel, J. Barzen, F. Leymann, L. Stiliadou, D. Vietz, and B. Weder, “Pattern-based generation and adaptation of quantum workflows,” in 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE, 2025, pp. 3072–3084.DOI
- [68]X. Wang, P. Arcaini, T. Yue, and S. Ali, “Qucat: A combinatorial testing tool for quantum software,” in 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE), 2023.arxiv.org/abs/2309.00119
- [69]Y. Li, M. Shao, J. Zhao, and Q. Wang, “A methodological analysis of empirical studies in quantum software testing,” ACM Transactions on Software Engineering and Methodology, 2026.






