Pith. sign in

REVIEW 3 major objections 5 minor 27 references

QuanUML: Towards A Modeling Language for Model-Driven Quantum Software Development

T0 review · 3 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read QuanUML brings quantum circuits into UML diagrams.

desk verdict A plausible UML extension for quantum circuits whose MDD/code-generation claim runs ahead of what the paper actually delivers. read the letter →

arxiv 2506.04639 v1 pith:EXR3ODRL submitted 2025-06-05 cs.SE

Xiaoyu Guo , Shinobu Saito , Jianjun Zhao This is my paper
classification cs.SE
keywords QuantumsoftwareengineeringModel-drivendevelopmentUnifiedModelingLanguagecircuitDynamiccircuitsShor'salgorithmQubitandgateHybridquantum-classicalsystems
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

QuanUML extends the Unified Modeling Language with constructs for qubits, quantum gates, and quantum circuits, so that quantum and hybrid quantum-classical software can be designed visually the way classical software already is. The authors demonstrate the notation on two algorithms: a dynamic circuit that teleports a long-range CNOT gate using mid-circuit measurement and classical feed-forward, and Shor's factoring algorithm for $N=15$. In both cases they show that the extended sequence diagrams and class diagrams can represent superposition, entanglement, measurement, and classical control. If the approach holds, model-driven development would become available for quantum software, with the eventual promise of generating executable code for platforms like Qiskit and Cirq from the diagrams.

What carries the argument

The load-bearing mechanism is the extended UML sequence diagram: qubit lifelines, gate messages whose synchrony encodes whether a gate is single-qubit or multi-qubit, and the control/controlled stereotypes that mark control flow and phase kickback. This notation is what is claimed to carry the representation of superposition, entanglement, and probabilistic measurement. The class diagram with the Quantum stereotype supplies the high-level hybrid-system view.

What would settle it

Implement a code generator from a QuanUML diagram and check whether it recovers the exact circuit intended in the paper's figures: for the long-range CNOT teleportation diagram, the generated Qiskit code should teleport a CNOT between qubits 0 and 5 with only the two depth-two gates and mid-circuit measurement described. If the diagram lacks enough information to fix gate order and control direction, the generated circuit will not match the intended unitary.

Watch

Extended reading notes

Core claim

QuanUML's central claim is that UML can be extended, without abandoning its notation, into a modeling language for quantum systems: qubit lifelines carry the stereotype “qubit,” single-qubit gates appear as asynchronous messages, and multi-qubit gates appear as synchronous, grouping messages with “control” and “controlled” stereotypes that show which qubit controls the operation and where phase kickback lands. Measurement is modeled as the end of a qubit lifeline together with a message that converts the outcome into a classical bit, and classical branching in dynamic circuits is represented by Alt fragments. At the class-diagram level, a “Quantum” stereotype marks quantum components. The paper argues that this unified notation covers static circuits, dynamic circuits, and hybrid algorithms such as Shor's, and that it needs fewer diagram elements than a UML profile-based alternative for single-qubit-gate-heavy circuits.

Load-bearing premise

The load-bearing premise is that a stereotype-bearing UML sequence diagram—qubit lifelines, synchronous and asynchronous gate messages, control/controlled labels—faithfully captures the quantum semantics of the gates it depicts, including superposition, entanglement, and phase kickback.

Editorial extensions

If this is right

  • Dynamic circuits, including mid-circuit measurement and feed-forward classical processing, can be expressed in a visual modeling language, a capability the paper says earlier UML-based methods lack.
  • A single QuanUML model can contain both classical and quantum components, so hybrid systems can be designed and reviewed in one notation instead of separate toolchains.
  • The element-count comparison indicates that QuanUML keeps diagrams compact for algorithms dominated by single-qubit gates, while multi-qubit gates with complex control relationships add elements because they are drawn in detail.
  • The high-level class diagram plus low-level sequence diagram combination lets large algorithms like Shor's be structured into reusable sub-circuits, which is the paper's route to scalable modeling.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A formal semantics mapping QuanUML diagram elements to quantum states and unitary operators is not given; without one, the notation is a communication sketch rather than a semantics-preserving modeling language, and two diagrams could denote the same gate in different-looking ways.
  • If a code generator were built on top of QuanUML, the rules for translating grouping messages into gate order and control direction would need to be made precise, since a synchronous message does not by itself fix the unitary of the gate.
  • The trade-off the paper observes—fewer elements for single-qubit gates but more for multi-qubit gates—suggests a possible extension: hybrid notations that mix message-based qubit interaction with circuit-symbol boxes for dense multi-qubit operations.
  • A natural next step beyond the two case studies is to test QuanUML on measurement-based patterns such as quantum teleportation and magic-state preparation, where the distinction between quantum and classical timing is subtle.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper proposes QuanUML, an extension of UML for model-driven quantum software development. QuanUML adds stereotypes and message conventions to UML sequence diagrams (e.g., <<qubit>>, <<classicalbit>>, <<control>>, <<controlled>>) and class diagrams (e.g., <<Quantum>>) to represent qubits, quantum gates, superposition, entanglement, and measurement, including dynamic circuits with mid-circuit measurement and classical control. The notation is illustrated with two case studies: Efficient Long-Range Entanglement using Dynamic Circuits and Shor's algorithm for N=15. The paper also compares QuanUML with prior UML-based quantum modeling approaches on functional coverage and diagram-element counts, and claims support for model-driven development with automatic code generation.

Significance. If the notation were given a precise, unambiguous semantics, QuanUML would fill a real gap in quantum software engineering: a visual, UML-compatible notation for hybrid quantum-classical systems, particularly dynamic circuits with classical feedforward, which existing UML profiles are not designed to handle. The case-study diagrams are substantial and do show that the notation can express gates, measurements, and classical control. The paper is also honest in places about what is not yet implemented, for example in Section VI where code generation is deferred to future work. However, as it stands the contribution is an informal proposal with illustrative diagrams rather than a demonstrated modeling language with well-defined semantics; the claimed model-driven code generation is not backed by a transformation engine or even a concrete mapping. With a formal semantics and a realistic code-generation demonstration, the work would be a solid basis for future quantum software modeling.

major comments (3)
  1. [Section I (Contributions) and Section VI] The contribution bullet in Section I states, as a contribution, 'automatic code generation' in the context of model-driven quantum software development, and Section III.C describes automated transformation to Qiskit/Cirq as a key benefit. Yet Section VI says 'Code generation remains a key area for future work,' and Section III.B.2 states that the proposed low-level framework 'establishes the foundation for future MDD-based code generation.' The paper therefore contradicts itself on a central claimed benefit. Please either remove the code-generation claim from the contributions and Section III.C, or provide at least a concrete transformation rule for a non-trivial fragment of the notation with a worked example (e.g., from a QuanUML diagram to openQASM or Qiskit).
  2. [Section III.B.2] The notation is specified only syntactically, with no formal mapping from QuanUML elements to quantum states or operators. For example, single-qubit gates are 'asynchronous messages,' multi-qubit gates are 'synchronous and grouping messages,' and control/controlled annotations are labels, but there is no rule stating which unitary a synchronous message denotes, how a grouping message is decomposed into a controlled gate, how the <<controlled>> annotation affects the target qubit, or how lifeline activation/deactivation corresponds to qubit creation and measurement. As a result, the same sequence diagram could be read as different circuits by different modelers, for instance a CNOT versus a controlled-phase gate in Figure 4, or with the phase-kickback arrow included or ignored. This is load-bearing for the model-driven development claim because code generation requires a determinate or canonical interpretation of the diagram. The authors should define a denotational semantics, or at least a deterministic translation to a standard quantum circuit representation.
  3. [Section IV.C (Table II)] The efficiency comparison in Table II is not reproducible or well defined. The metric 'number of elements' is never defined, no counting procedure is given, and the rendered table content appears garbled in the manuscript (for example, the Bell State row shows '1020' and the column headers are unreadable). The claim that QuanUML needs 'fewer elements while maintaining the same performance' is therefore not supported as stated. Please define the element grammar used for counting, report the counts with a clear unit, and either measure 'same performance' or drop that phrase.
minor comments (5)
  1. [Section IV.A.2] The text says 'Group messages represent multi-quit gates'; this should read 'multi-qubit gates.'
  2. [Section IV.C (Tables I and II)] The column alignment and row labels in Tables I and II are difficult to parse in the current rendering; please reformat the tables so that each row is clearly identified and each cell maps to a named method and a named task or algorithm.
  3. [Section IV.B.2] The sentence 'previous quantum modeling methods have primarily overlooked this approach' is too broad and is not tied to a specific cited method; please name the methods and discuss their treatment of custom gates.
  4. [References] The reference list order is inconsistent: reference [4] appears after [5] and [6] in the list, and some entries (e.g., [17], [22], [27]) use inconsistent formatting; please reorder and unify the bibliography.
  5. [Section III.A (Figure 1)] Figure 1 shows 'code generation' as a stage of the QuanUML workflow, but the body text in Section III.A says the details are discussed in Section VI, which in turn says code generation is future work; please align the workflow diagram with the actual current capabilities of the proposal.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: QuanUML is a notation proposal with illustrative case studies; no predicted quantity is derived from fitted inputs or self-citations.

full rationale

QuanUML is a notation proposal: Section III defines stereotypes and message conventions, and Section IV draws diagrams of two algorithms in that notation. There is no derivation chain in which an output is equivalent to an input. The element-count comparison in Table II compares counts in the authors' QuanUML diagrams with counts in the prior UML-profile diagrams; although the counting metric is author-chosen, it is a direct artifact comparison and not a fitted parameter renamed as a prediction. The only self-citation, reference [7] by author Zhao, supports background statements about quantum software challenges and is not load-bearing for the language's design or evaluation. The paper's internal inconsistency, claiming automatic code generation in the contributions and Section III.C while Section VI states 'Code generation remains a key area for future work,' is a correctness and scope problem, not circularity. No quoted reduction of any claimed result to its own inputs is present.

Assumptions & free parameters 0 free parameters · 3 assumptions · 1 invented entities

No fitted numerical parameters appear. The central claim rests on informal assumptions about how UML semantics extend to quantum constructs, on an ad hoc element-count metric, and on a decomposition strategy for hybrid systems. These are reasonable starting points for a modeling-language proposal but none are formally justified.

assumptions (3)
  • domain assumption UML sequence diagrams can be extended with stereotypes and synchronous and asynchronous messages to faithfully represent quantum state evolution, measurement, and phase kickback.
    Invoked throughout Section III.B, especially the representation of multi-qubit gates as synchronous messages; no formal semantics is provided.
  • ad hoc to paper The number of elements in a QuanUML diagram is a meaningful proxy for modeling efficiency and is directly comparable across modeling methods.
    Table II uses this count to claim QuanUML is more efficient, but the counting rule is never defined and no objective or inter-rater metric is given.
  • domain assumption A class-diagram and sequence-diagram pair can capture both high-level architecture and low-level circuit detail without information loss.
    Section IV.B.2 applies this decomposition to Shor's algorithm; the paper does not prove completeness or consistency of the two modeling levels.
invented entities (1)
  • QuanUML stereotype set (qubit, classicalbit, control, controlled, Quantum)
    purpose: Encoding quantum semantics in standard UML diagrams
    The notation is proposed by this paper and is validated only by the authors' own case-study diagrams; there is no external tool, formal semantics, or third-party use yet.

how reviews work

0 comments
Cite this review

Pith. "Pith review of QuanUML: Towards A Modeling Language for Model-Driven Quantum Software Development." pith.science (2026). https://pith.science/paper/EXR3ODRL

@misc{pith2026250604639,
  author       = {Pith},
  title        = {Pith review of: QuanUML: Towards A Modeling Language for Model-Driven Quantum Software Development},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EXR3ODRL}},
  note         = {Machine review of arXiv:2506.04639}
}
read the original abstract

This paper introduces QuanUML, an extension of the Unified Modeling Language (UML) tailored for quantum software systems. QuanUML integrates quantum-specific constructs, such as qubits and quantum gates, into the UML framework, enabling the modeling of both quantum and hybrid quantum-classical systems. We apply QuanUML to Efficient Long-Range Entanglement using Dynamic Circuits and Shor's Algorithm, demonstrating its utility in designing and visualizing quantum algorithms. Our approach supports model-driven development of quantum software and offers a structured framework for quantum software design. We also highlight its advantages over existing methods and discuss future improvements.

Figures

Figures reproduced from arXiv: 2506.04639 by the authors.

Figure 1
Figure 1. An overview of QuanUML Workflow have made it an indispensable tool in many classical software engineering projects. 3) Limitations of UML in Quantum Context: Despite its widespread use in classical software engineering, UML is not inherently suited to model quantum systems. The main limita￾tion lies in its inability to capture quantum-specific phenom￾ena, such as superposition, entanglement, and the probabilistic na… view at source ↗
Figure 3
Figure 3. The sequence diagram of Bell State in QuanUML [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figure 4
Figure 4. The sequence diagram of Long-range CNOT teleportation using dynamic circuit. [PITH_FULL_IMAGE:figures/full_fig_p006_4.png] view at source ↗
Figures from the paper (4 more)
Figure 5
Figure 5. Figure 5: The class diagram of Shor’s Algorithm in QuanUML. [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Abstract sequence diagram of Shor’s Algorithm. [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]
Figure 7
Figure 7. Figure 7: Low level sequence diagram of Shor’s Algorithm. [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: The sequence diagram of period finding for 7 mod 15. [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

27 extracted references · 22 canonical work pages

  1. [1]

    Towards quantum chemistry on a quantum computer,

    B. P. Lanyon, J. D. Whitfield, G. G. Gillett, M. E. Goggin, M. P. Almeida, I. Kassal, J. D. Biamonte, M. Mohseni, B. J. Powell, M. Barbi- eri et al., “Towards quantum chemistry on a quantum computer,” Nature chemistry, vol. 2, no. 2, pp. 106–111, 2010

    work page 2010

  2. [2]

    Superconducting quantum circuits at the surface code threshold for fault tolerance,

    R. Barends, J. Kelly, A. Megrant, A. Veitia, D. Sank, E. Jeffrey, T. C. White, J. Mutus, A. G. Fowler, B. Campbell et al. , “Superconducting quantum circuits at the surface code threshold for fault tolerance,” Nature, vol. 508, no. 7497, pp. 500–503, 2014

    work page 2014

  3. [3]

    Quantum learning robust against noise,

    A. W. Cross, G. Smith, and J. A. Smolin, “Quantum learning robust against noise,” Physical Review A , vol. 92, no. 1, p. 012327, 2015

    work page 2015

  4. [4]

    Estimation of effective temperatures in quantum annealers for sampling applications: A case study with possible applications in deep learning,

    M. Benedetti, J. Realpe-G ´omez, R. Biswas, and A. Perdomo-Ortiz, “Estimation of effective temperatures in quantum annealers for sampling applications: A case study with possible applications in deep learning,” Physical Review A , vol. 94, no. 2, p. 022308, 2016

    2016

  5. [5]

    Scalable quantum simulation of molecular energies,

    P. J. O’Malley, R. Babbush, I. D. Kivlichan, J. Romero, J. R. McClean, R. Barends, J. Kelly, P. Roushan, A. Tranter, N. Ding et al., “Scalable quantum simulation of molecular energies,” Physical Review X , vol. 6, no. 3, p. 031007, 2016

    work page 2016

  6. [6]

    Quantum Information and Computation for Chemistry

    J. Olson, Y . Cao, J. Romero, P. Johnson, P.-L. Dallaire-Demers, N. Sawaya, P. Narang, I. Kivlichan, M. Wasielewski, and A. Aspuru- Guzik, “Quantum information and computation for chemistry,” arXiv preprint arXiv:1706.05413, 2017

    work page Pith review arXiv 2017

  7. [7]

    Quantum software engineering: Landscapes and horizons,

    J. Zhao, “Quantum software engineering: Landscapes and horizons,” arXiv preprint arXiv:2007.07047 , 2020

    arXiv 2007

  8. [8]

    Quantum computation and quantum information,

    M. A. Nielsen and I. Chuang, “Quantum computation and quantum information,” 2002

    2002

Show all 27 references
  1. [9]

    Model-driven development,

    S. J. Mellor, A. N. Clark, and T. Futagami, “Model-driven development,” IEEE software, vol. 20, no. 5, p. 14, 2003

    2003

  2. [10]

    Towards model-driven quantum software engineering,

    F. Gemeinhardt, A. Garmendia, and W. Manuel, “Towards model-driven quantum software engineering,” in Second International Workshop on Quantum Software Engineering (Q-SE 2021) , 2021, pp. 16–21

    2021

  3. [11]

    Booch, J

    G. Booch, J. Rumbaugh, and I. Jacobson, The unified modeling language user guide. addison-wesley, 1999

    1999

  4. [12]

    Efficient long-range entanglement using dynamic circuits,

    E. B ¨aumer, V . Tripathi, D. S. Wang, P. Rall, E. H. Chen, S. Majumder, A. Seif, and Z. K. Minev, “Efficient long-range entanglement using dynamic circuits,” PRX Quantum, vol. 5, no. 3, p. 030339, 2024

    2024

  5. [13]

    Algorithms for quantum computation: discrete logarithms and factoring,

    P. W. Shor, “Algorithms for quantum computation: discrete logarithms and factoring,” in Proceedings 35th annual symposium on foundations of computer science . Ieee, 1994, pp. 124–134

    1994

  6. [14]

    Research, “Qiskit,” Accessed on: November, 2024 , 2024

    I. Research, “Qiskit,” Accessed on: November, 2024 , 2024. [Online]. Available: https://qiskit.org

    2024

  7. [15]

    G. A. Q. team, “Cirq,” 2018. [Online]. Available: https://github.com/ quantumlib/Cirq

    2018

  8. [16]

    Introduction to coding quantum algorithms: A tutorial series using pyquil,

    D. Koch, L. Wessing, and P. M. Alsing, “Introduction to coding quantum algorithms: A tutorial series using pyquil,” arXiv preprint arXiv:1903.05195, 2019

    1903 arXiv

  9. [17]

    Thinking too classically: research topics in human-quantum computer interaction,

    Z. Ashktorab, J. D. Weisz, and M. Ashoori, “Thinking too classically: research topics in human-quantum computer interaction,” in Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems , 2019, pp. 1–12

    2019

  10. [18]

    Version 2.2. OMG specification superstructure and infrastructure,

    O. UML, “Version 2.2. OMG specification superstructure and infrastructure,” 2009. [Online]. Available: https://www.omg.org/spec/ UML/2.2/

    2009

  11. [19]

    Rurnbaugh, I

    J. Rurnbaugh, I. Jacobson, and G. Booch, The unified modeling language reference manual. addison-wesley, 1999

    1999

  12. [20]

    Towards a quantum software modeling language,

    C. A. P ´erez-Delgado and H. G. Perez-Gonzalez, “Towards a quantum software modeling language,” in First International Workshop on Quan- tum Software Engineering (Q-SE 2020) , 2020

    2020

  13. [21]

    Modeling quantum programs: challenges, initial re- sults, and research directions,

    S. Ali and T. Yue, “Modeling quantum programs: challenges, initial re- sults, and research directions,” in Proceedings of the 1st ACM SIGSOFT International Workshop on Architectures and Paradigms for Engineering Quantum Software, 2020, pp. 14–21

    2020

  14. [22]

    The quantum software engineering path,

    R. P ´erez-Castillo and M. Piattini, “The quantum software engineering path,” in Short Papers, Proceedings of the 1st International Workshop on Quantum Software Engineering and Technologyg , ser. CEUR Workshop Proceedings, vol. 2705. CEUR-WS.org, 2020, pp. 1–4. [Online]. Avail...

    2020

  15. [23]

    Quantum computing and shors factoring algorithm,

    I. V . V olovich, “Quantum computing and shors factoring algorithm,” arXiv preprint quant-ph/0109004 , 2001

    2001 arXiv

  16. [24]

    Design of classical-quantum systems with uml,

    R. P ´erez-Castillo and M. Piattini, “Design of classical-quantum systems with uml,” Computing, vol. 104, no. 11, pp. 2375–2403, 2022

    2022

  17. [25]

    Quantum computing with Qiskit,

    A. Javadi-Abhari, M. Treinish, K. Krsulich, C. J. Wood, J. Lishman, J. Gacon, S. Martiel, P. D. Nation, L. S. Bishop, A. W. Cross, B. R. Johnson, and J. M. Gambetta, “Quantum computing with Qiskit,” 2024

    2024

  18. [26]

    Q#: enabling scalable quantum computing and development with a high-level DSL,

    K. Svore, A. Geller, M. Troyer, J. Azariah, C. Granade, B. Heim, V . Kliuchnikov, M. Mykhailova, A. Paz, and M. Roetteler, “Q#: enabling scalable quantum computing and development with a high-level DSL,” in Proceedings of the Real World Domain Specific Languages Workshop 2018,...

    2018

  19. [27]

    Amazon Braket,

    Amazon Web Services, “Amazon Braket,” 2020. [Online]. Available: https://aws.amazon.com/braket/ 10

    2020

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.