Quantum computing introduces a new approach to computation by using quantum mechanical phenomena to perform calculations that are difficult for classical computers. It relies on superposition, where quantum bits (qubits) can exist in multiple states simultaneously, and entanglement, which connects the states of multiple qubits such that no single qubit’s state can be determined independently. These characteristics enable quantum computers to process information in parallel, enhancing the speed of certain computations. However, quantum mechanics also brings specific limitations, notably the no-cloning theorem [1], which prevents the exact duplication of an arbitrary unknown quantum state. This principle is essential to quantum information theory and affects quantum cryptography, error correction, and communication protocols.

While quantum software development is advancing, there remains a gap in software engineering methods for modeling and representing quantum mechanical principles like the no-cloning theorem. Metamodeling techniques, particularly those based on UML, have been effective in outlining domain concepts and relationships in emerging areas. These frameworks offer detailed abstractions and formal specifications that can adapt to include quantum mechanical principles. When extended, these methods provide a foundation for designing, analyzing, and validating quantum software systems, helping to bridge the gap between quantum mechanics and software engineering methodologies.

Several quantum software modeling approaches have been proposed (e.g., [2–6]). These include graph-based modeling of unitary circuits, offering circuit-level abstractions for quantum computation using model-driven engineering [2]; a UML profile for designing hybrid classical-quantum systems through stereotypes and multiple diagram types [3]; the Talavera Manifesto, which outlines principles and commitments for establishing quantum software engineering as a discipline [4]; a lifecycle model for developing hybrid quantum applications that integrate quantum and classical components via workflow technology [5]; and a quantum software testing framework that addresses post-implementation quality assurance challenges [6]. However, there remains a clear gap in the availability of rigorous theoretical frameworks for the formal design and verification of quantum-specific constraints, particularly the no-cloning theorem. Such a framework is crucial for supporting traditional software engineers, who are experienced in classical software development but often lack expertise in quantum software principles.

This paper presents a metamodeling approach using UML-style notation to describe the no-cloning theorem in quantum mechanics, demonstrating how traditional software engineering techniques can effectively represent and analyze quantum principles. The metamodel defines key quantum concepts related to the no-cloning theorem and their relationships, incorporating formal invariants to reinforce quantum mechanical constraints. Two edge cases—conditional copying with CNOT gates and quantum teleportation—are examined through instance models to assess the metamodel’s effectiveness in analyzing quantum principles. While these cases may seem to violate the no-cloning theorem, the analysis confirms their compliance with its constraints. This metamodeling approach provides a structured framework that integrates quantum mechanics with software engineering, helping traditional software engineers better engage with quantum computing and apply established software engineering methodologies to quantum software development.

The remainder of this paper is structured as follows: Section 2 provides an overview of related work. Section 4 discusses the no-cloning theorem and introduces the metamodel for the theorem. Section 5 describes two edge cases of cloning, captured by instance models of the metamodel and their implementations. Section 8 concludes the paper and outlines future research directions.

Recent research in quantum software engineering has focused on applying modeling techniques to quantum computing systems. Alonso et al. [2] developed a unified metamodel for quantum circuits using model-driven engineering, showing how systematic modeling can standardize quantum software development. Following this, Sánchez and Alonso [7] investigated modularity in quantum programming, addressing challenges related to non-clonability and probabilistic operations. Bibbo et al. [8] conducted a comprehensive review of software engineering resources in quantum computing, emphasizing the importance of modeling across the software lifecycle.

The theoretical foundation for quantum software engineering has been developed through several studies. Ahmad et al. [9] discussed the integration of quantum mechanics principles with software engineering practices, particularly focusing on quantum software architectures and their importance in development and validation. Ali et al. [10] analyzed the need for new methodologies that can handle quantum characteristics such as superposition and entanglement. Pérez-Castillo and Piattini [3] proposed a UML profiling mechanism that extends standard UML to support the design of hybrid classical-quantum systems by modeling quantum components, classical-quantum interactions, and system architectures. Piattini et al. [4] present Talavera Manifesto which emphasizes the foundational vision for quantum software engineering (QSE) as a discipline, proposing broad principles and commitments for systematically building, testing, maintaining, and managing quantum software at an industrial scale. Their work advocates for adapting classical software engineering processes to quantum contexts and highlights the importance of governance, quality assurance, reuse, and security. In contrast, the our work provides a much more concrete and technical contribution by introducing a formal metamodel with OCL constraints that captures fundamental quantum mechanical laws, specifically the no-cloning theorem, aiming to prevent conceptual errors at the design phase. Thus, while the Talavera Manifesto lays out a high-level roadmap for the future of QSE as a discipline, our work operationalizes part of that vision by formally modeling quantum-specific constraints that can be directly applied in early-stage quantum software modeling.

Implementation aspects of quantum software systems have been explored through various methods. Sabzevari et al. [11] introduced quantum computing as a service to broaden access to quantum computing resources. Gallardo et al. [12] developed Quirk+, a tool that enhances quantum circuit development capabilities. The work by Weder et al. [5] presents a comprehensive lifecycle framework for developing hybrid quantum applications that integrate quantum and classical components. They focus on orchestrating these components through workflow technology and present three interwoven lifecycles: the quantum workflow lifecycle, the classical software lifecycle, and the quantum circuit lifecycle. Their approach emphasizes practical implementation considerations such as deployment, observability, and DevOps practices. In contrast, our work advances the conceptual formalization of quantum mechanical principles, specifically the no-cloning theorem, by introducing a UML-based metamodel with OCL constraints. While both works bridge quantum computing and software engineering, Weder et al. emphasize operational processes, covering the entire application lifecycle, whereas our work concentrates on formalizing specific quantum mechanical principles, enforcing fundamental quantum constraints at the modeling phase to demonstrate how traditional software modeling techniques can be adapted to quantum software development.

Testing and validation in quantum systems present unique challenges. Garcia de la Barrera et al. [13] analyzed existing strategies in quantum software testing, focusing on the inadequacies of classical testing methods for quantum systems. Ali [6] presents an introductory overview of quantum software testing (QST), focusing on the challenges of testing quantum programs due to the unique characteristics of quantum computing (e.g., superposition, entanglement). The work outlines three main topics: quantum computing fundamentals, QST challenges compared to classical software testing, and current QST techniques along with their limitations. Ali specifically highlights specialized testing approaches such as input/output coverage criteria, metamorphic testing, and noise-aware testing for quantum programs. In contrast, our work addresses pre-implementation correctness by formally modeling quantum mechanical constraints—specifically the no-cloning theorem—through a UML-based metamodel with OCL constraints. Rather than testing quantum software after it is built, our work aims to embed quantum correctness directly into the design phase, preventing conceptual errors at the modeling level. Thus, whereas Ali emphasizes improving the quality assurance process for quantum software, our work emphasizes design-time correctness enforcement rooted in fundamental quantum principles.

Process management in quantum software development has been explored in various studies. Khan et al. [14] examined the integration of agile practices into quantum software development, using interviews with practitioners from multiple countries. Separately, Thompson et al. [15] investigated the use of machine learning with quantum computing, suggesting non-algorithmic approaches to programming that are suited for Noisy Intermediate-Scale Quantum (NISQ) devices.

This diverse body of research highlights the advancing maturity of quantum software engineering. This work builds on these foundations by focusing on the formal representation of the no-cloning theorem through metamodeling, aiming to connect traditional software engineering practices with the development of quantum software systems.

In this section, we compare the metamodeling approach with quantum circuit diagrams [1], and other quantum software modeling approaches [2,3].

In this section, we discuss the no-cloning theorem and introduce a metamodel that represents it. Theorem 1 [1] details the no-cloning theorem.

Theorem 1 (No-Cloning Theorem): The no-cloning theorem states that creating an exact copy of an arbitrary unknown quantum state is impossible. This theorem is crucial as it sets fundamental limits on quantum computing and information processing, in contrast to classical mechanics where state duplication is feasible.

Consider a quantum machine designed to clone quantum states, which includes two slots: slot A (data slot) and slot B (target slot). Slot A contains an unknown pure quantum state |ψ⟩, and slot B starts in a standard pure state |s⟩. The initial combined state of the system can be represented by Eq. (1): (1)|ψ⟩⊗|s⟩.where ⊗ denotes the tensor product of the states in slots A and B.

Suppose there is a unitary operation U purported to clone quantum states. Specifically, U is applied to the combined system with the state defined by Eq. (1). The intended outcome of this operation is to duplicate the state |ψ⟩, as shown in Eq. (2): (2)U(|ψ⟩⊗|s⟩)=|ψ⟩⊗|ψ⟩.

Assuming the cloning process works for states |ψ⟩ and |ϕ⟩, the effects of the unitary operation can be examined by considering inner products, as shown in Eq. (3): (3)U(|ψ⟩⊗|s⟩)=|ψ⟩⊗|ψ⟩,U(|ϕ⟩⊗|s⟩)=|ϕ⟩⊗|ϕ⟩

For any two states |ψ⟩ and |ϕ⟩, a unitary operation U must comply with Eq. (4): (4)⟨ψ|ϕ⟩=⟨Uψ|Uϕ⟩

This stipulates that the inner product between the states before applying U must equal the inner product between the states after applying U.

In the hypothetical cloning scenario, before applying the unitary operation U, the states |ψ⟩ and |s⟩ (the standard state) are combined using tensor products, as are |ϕ⟩ and |s⟩. The objective of U is to replicate |ψ⟩and |ϕ⟩. If successful, after applying U, the states would transform into |ψ⟩⊗|ψ⟩ and |ϕ⟩⊗|ϕ⟩, respectively. This transformation is represented in Eq. (5): (5)⟨U(ψ⊗s)|U(ϕ⊗s)⟩=⟨ψ⊗ψ|ϕ⊗ϕ⟩

Given the unitarity of U, the following equation holds: (6)⟨U(ψ⊗s)|U(ϕ⊗s)⟩=⟨ψ⊗s|ϕ⊗s⟩

If we assume cloning is feasible, then Eq. (5) is simplified by Eq. (6) to: (7)⟨ψ⊗s|ϕ⊗s⟩=⟨ψ⊗ψ|ϕ⊗ϕ⟩

Unitary operations must preserve the inner products of states, meaning if U could theoretically clone both |ψ⟩ and |ϕ⟩, their post-cloning inner products must reflect their original inner products. The inner product between tensor product states ⟨ψ⊗s|ϕ⊗s⟩ can be decomposed into the product of the inner products of their components due to the separable nature of tensor products in Hilbert spaces, as shown in Eq. (8). (8)⟨ψ|ϕ⟩⟨s|s⟩where ⟨ψ|ϕ⟩is the overlap between |ψ⟩ and |ϕ⟩, and ⟨s|s⟩ is the self-inner product of |s⟩. Assuming |s⟩is normalized, ⟨s|s⟩=1, leading to Eq. (9). (9)⟨ψ⊗s|ϕ⊗s⟩=⟨ψ|ϕ⟩

This result shows that the similarity or overlap between the tensor product states |ψ⊗s⟩ and |ϕ⊗s⟩ is determined solely by the overlap between |ψ⟩ and |ϕ⟩, with the normalized state |s⟩ having no impact on the comparison.

After applying U, Eq. (10) is established since the tensor product of inner products is the product of the inner products. (10)⟨ψ⊗ψ|ϕ⊗ϕ⟩=⟨ψ|ϕ⟩⟨ψ|ϕ⟩=⟨ψ|ϕ⟩2

Then, Eq. (9) simplifies to Eq. (11). (11)⟨ψ|ϕ⟩=⟨ψ|ϕ⟩2

This equation holds true only if ⟨ψ|ϕ⟩=0 or ⟨ψ|ϕ⟩=1, indicating that |ψ⟩ and |ϕ⟩ must be either the same state or orthogonal states. This result demonstrates that a unitary cloner can effectively operate for two states only if those states are either identical or orthogonal. For orthogonal states, the inner product is zero, which means there is no overlap between the states and they are perfectly distinguishable with a probability of 1 upon measurement. This ensures a 100% probability of correctly identifying the state as either |ψ⟩ or |ϕ⟩ without confusion. Orthogonality before applying a unitary operation implies they must remain orthogonal afterward.

However, for general quantum states that are neither orthogonal nor identical, no such unitary cloner U can exist, as no unitary operation can satisfy this equation for all possible pairs of states, thereby negating the possibility of a universal cloner. When states are non-orthogonal, they have a non-zero probability amplitude overlap, indicating they cannot be perfectly distinguished by any measurement. Non-orthogonal states, due to their inherent overlap, cannot be perfectly cloned as this would necessitate altering the inner product, which is invariant under unitary evolution. This fundamental limitation applies to both pure and mixed states.

Fig. 1 illustrates a metamodel for the no-cloning theorem in quantum mechanics using UML-style notation to outline quantum concepts, their relationships, and multiplicity constraints. The model was developed using StarUML¹1

https://staruml.io (accessed on 25 May 2025).

We employ the Object Constraint Language (OCL) [16], a companion language to UML, to specify the principles of the no-cloning theorem on relevant metaclasses. Invariant (12) maintains that the inner product of orthogonal states must be zero, emphasizing the uniqueness and independence of orthogonal quantum states in cloning operations. (12)Context:CloneInv:InnerProductPreservationself.Qubit→(forAll q1,q2∣if q1.State.orthogonal→includes(q2.State)thenq1.State.innerProduct(q2.State)=0elsetrue)

Invariant (13) ensures the unitarity of matrices within the system, a fundamental property in quantum mechanics that governs state evolution. Notably, unitarity is a sufficient condition for general inner product preservation across quantum operations. In contrast, Invariant (12), defined specifically in the context of cloning, explicitly enforces that inner products between orthogonal states must be preserved in hypothetical cloning operations, reflecting a core constraint of the no-cloning theorem. (13)Context:MatrixInv:Unitarity(self.multiply(self.adjoint())=Matrix::identity()andself.adjoint().multiply(self))=Matrix::identity()))

Invariant (14) enforces the no-cloning theorem by ensuring that no universal cloning operation can replicate all quantum states. It specifies that for any cloning operation, if two qubits have distinct states, they must remain distinct unless they are orthogonal. If orthogonal, the operation may result in the states becoming identical, reflecting the ability to clone states only when their orthogonal relationship is predefined, and prior knowledge of the states is available. (14)Context:CloneInv:CloneInvariantself.qubit→forAll(q1, q2|let s1:State= q1.State,s2:State =q2.State inif s1≠s2then (not self.applyTensor(s1, s2) = s1.tensor(s1) andnot self.applyTensor(s1, s2) = s2.tensor(s2)) or(s1.orthogonal→includes (s2) impliesself.applyTensor(s1, s2) = s1.tensor(s1) orself.applyTensor(s1, s2) = s2.tensor(s2))elsetrue

Invariant (15) ensures that any Entanglement associated with a Teleportation operation involves only those Qubit instances that participate in the Teleportation. This constraint enforces consistency between the qubits engaged in the teleportation protocol and those entangled as part of its implementation. (15)Context:TeleportationInv:TeleportationEntanglementself.Entanglement.Qubit→forAll(q∣self.Qubit→includes(q))

In teleportation, the receiving (target) qubit is adjusted to replicate the original state through classical communication. Invariant (16) ensures that the target qubit of a teleportation operation is included among the qubits associated with its corresponding classical communication line. (16)Context:TeleportationInv:TeleportationCommunicationself.ClassicalCommunicationLine.Qubit→includes(self.target)

Invariant (17) ensures that the original quantum state is destroyed during the Bell-state measurement phase of teleportation. It prohibits the coexistence of the original and teleported quantum states, thereby preventing any implicit or residual duplication of state information. (17)Context:TeleportationInv:TeleportationDestructionself.source.Measurement→notEmpty() impliesself.source.State.oclIsUndefined()

While the proposed metamodel provides a structural foundation for representing key quantum computing concepts, it is important to acknowledge its limitations in directly modeling dynamic phenomena such as quantum state evolution. Quantum state evolution, governed by continuous unitary transformations and probabilistic measurement collapses, involves temporal and process-oriented behaviors that static structural metamodels, such as those based on UML, are not inherently designed to capture. However, relevant constraints associated with quantum state evolution (e.g., unitarity, inner product preservation) can be formally expressed through OCL, as demonstrated. Similarly, while the no-cloning impossibility is captured in the proposed metamodel through a dedicated Clone metaclass and associated OCL invariants, the enforcement of no-cloning across dynamic sequences of operations exceeds the expressiveness of static class diagrams.

The no-cloning theorem forms a fundamental basis for quantum computing and is explicitly integrated into the design of the proposed metamodel; therefore, it does not adversely affect model interoperability. Any models developed based on the metamodel remain inherently interoperable by design. In current quantum computing practice, modularity is typically defined at the level of operations and algorithms, both of which are explicitly represented within the metamodel, thereby ensuring strong modularity support. We anticipate that the metamodel will continue to evolve and expand to encompass a broader range of quantum computing aspects, enhancing its flexibility and applicability for developing diverse quantum software systems.

The no-cloning theorem is a fundamental law of quantum mechanics and does not directly impact model qualities such as reusability. Model qualities are typically determined at the instance-level (design-level) of the metamodel by applying software engineering principles such as coupling, cohesion, and separation of concerns, as established in traditional software engineering. The applicability of these traditional principles to quantum software systems remains an open area for further investigation. Once reusability is intentionally designed at the model-level, it is inherently reflected in the construction of programming components at the implementation-level.

In quantum communication systems (e.g., quantum teleportation, entanglement swapping [1]), which transmit information between two or more parties using quantum phenomena such as superposition and entanglement, the constraints imposed by the no-cloning theorem can be used to reason about the impossibility of duplicating qubit states during information transfer. The metamodel helps structurally represent these systems while formally enforcing no-cloning constraints through OCL invariants, thereby enabling systematic validation of quantum communication protocols to ensure they adhere to fundamental quantum mechanical principles.

The metamodel can be extended to support approximate or probabilistic cloning techniques (e.g., universal quantum cloning machines (UQCM) [17]), which allow the creation of imperfect copies of quantum states by relaxing the strict limitations of the no-cloning theorem at the cost of reduced fidelity. This can be achieved by extending the Clone metaclass into a hierarchy representing different types of cloning: perfect cloning (strictly prohibited by the no-cloning theorem for arbitrary unknown states), approximate cloning (allowing imperfect copies with reduced fidelity), and probabilistic cloning (allowing perfect copies but only with a certain probability). Depending on how these extended elements are incorporated into the model, the fidelity of quantum simulations may vary, with approximate cloning introducing fidelity degradation and probabilistic cloning introducing conditional success rates. Such extensions would enhance the metamodel’s practical applicability to real-world quantum systems where noise and imperfections exist.

This section examines two edge cases – conditional copying using CNOT gates and quantum teleportation – through instance models to evaluate the metamodel’s effectiveness in analyzing quantum principles. All instance models were created using StarUML. These two scenarios were selected based on the following criteria: (1) both are canonical operations in quantum computing that are commonly misinterpreted as potential violations of the no-cloning theorem, and (2) each exercises distinct aspects of the metamodel and its associated OCL invariants. The CNOT case specifically tests constraints related to orthogonality and conditional behavior (e.g., Invariants (12) and (14)), while the teleportation case engages constraints involving state destruction, entanglement, and classical communication consistency (e.g., Invariants (15)–(17)). Together, these cases probe the boundary conditions of cloning behavior and validate the internal consistency of the metamodel’s formal constraints.

In this section, we discuss the implicit validation embedded in the approach itself, as well as the practical application of the proposed approach in real-world quantum software engineering contexts.

This section discusses potential threats to the validity of the proposed metamodeling approach, organized according to common validity dimensions: internal validity, external validity, construct validity, and conclusion validity.

Internal Validity. Internal validity is concerned with the correctness of the metamodel, which relies on the formal representation of quantum mechanical principles using OCL constraints. Any misinterpretation or incomplete formalization of these principles could lead to inaccurate modeling. We mitigated this threat by grounding the constraints in established quantum mechanical formulations [1]. The translation from mathematical notation to OCL introduces another potential source of error. Different interpretations of quantum mechanical equations could result in varying constraint definitions. To address this concern, we provided detailed explanations of the mapping between quantum mathematical formulations and corresponding OCL expressions.

External Validity. External validity pertains to the generalizability of the metamodel beyond the specific cases analyzed. Although the presented edge cases are representative and grounded in canonical quantum behavior, the applicability of the metamodel to other quantum phenomena—such as mixed states, approximate cloning, entanglement distillation, or quantum error correction—has not yet been explored. To address this limitation, we demonstrate the extensibility of the metamodel through the incorporation of projective measurement, as discussed in Section 6. Additionally, the validation focused on relatively simple quantum systems with few qubits. While the metamodel and its associated OCL invariants are not directly impacted by system scale—since the metamodel abstracts quantum concepts independently of the number of qubits—scalability concerns arise primarily at the instance level. As the system grows, an increasing number of metaclass instances (e.g., Qubit, State, Measurement) must be created and managed. This expansion may introduce computational overhead, particularly in evaluating OCL constraints over large collections of instances. Additionally, state explosion may become a practical concern at the instance-level. As quantum systems evolve—particularly those involving entangled or superposed states—the complexity of instance models increases, making it more difficult to maintain, validate, and reason about their correctness without dedicated tool support.

Construct Validity. Construct validity concerns whether the metamodel accurately represents the theoretical concepts it is intended to capture—in this case, the principles underlying the no-cloning theorem. While the metamodel is grounded in quantum mechanical formalism and includes formal constraints (e.g., unitarity, inner product preservation) via OCL invariants, it may still omit subtle physical nuances (e.g., imperfect gates, noise) not easily formalized in UML-based notation. Additionally, the mapping of inherently mathematical quantum operations to software modeling constructs may lead to oversimplification or loss of semantic nuance.

This paper employs metamodeling techniques to analyze the no-cloning theorem in quantum mechanics through a UML-style metamodel. This metamodel incorporates essential quantum concepts and relationships relevant to the no-cloning theorem, emphasizing the inability to replicate arbitrary unknown quantum states. It validates its utility with instance models that explore edge cases like conditional copying with CNOT gates and quantum teleportation, ensuring they adhere to the theorem’s constraints in line with conventional software engineering practices. This research provides the quantum software engineering community with a structured framework for integrating quantum mechanics into software design, promoting advancements in quantum software development. There is also a potential learning curve for software engineers who may lack quantum mechanics background. This interdisciplinary knowledge gap could limit the approach’s adoption. However, by leveraging UML—a widely practiced and standardized graphical modeling language in software engineering—as the foundation of the approach, the barrier to entry is significantly reduced. UML provides a familiar and intuitive framework for software engineers, allowing them to engage with quantum concepts without requiring deep mathematical expertise. By embedding quantum principles within this modeling paradigm, the approach translates complex mathematical formalisms into structured visual representations and declarative rules. These abstractions serve as conceptual scaffolding, helping learners incrementally develop intuition for quantum behavior without being overwhelmed by the underlying formalism.

Future work will focus on broadening the scope of the metamodel beyond the no-cloning theorem. Specifically, we plan to explore its applicability to other areas of quantum computing such as mixed states, approximate cloning, entanglement distillation, and quantum error correction. These topics introduce additional complexity, including probabilistic behaviors, partial fidelity constraints, and hybrid quantum-classical interactions. Extending the metamodel to represent such phenomena will require incorporating new modeling constructs, constraints, and validation mechanisms, and will serve to assess the scalability, flexibility, and robustness of the approach across a wider range of quantum scenarios. The practical utility of the metamodel for quantum software developers depends on integration with existing quantum development tools and workflows. Currently, most quantum programming relies on circuit-based representations rather than UML-style models. Further work is needed to bridge the gap between the metamodeling approach and practical quantum software development environments. By doing so, we aim to further integrate metamodeling with the evolving needs of quantum software engineering.