Pith. sign in

REVIEW 4 major objections 5 minor 31 references

A Denotational Semantics for Quantum Loops

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read Quantum while loops get a denotation that handles infinite runs

desk verdict The limit construction is clean and mostly correct for flat while loops, but nested loops break the fresh-ancilla assumption and the semantics is not compositional for the language it defines. read the letter →

arxiv 2506.23320 v1 pith:D5J2QDNX submitted 2025-06-29 cs.PL

Nicola Assolini , Alessandra Di Pierro This is my paper · ORCID
classification cs.PL MSC 68Q5581P68
keywords quantumprogramminglanguagesdenotationalsemanticswhileloopscontrolflowboundedlinearoperatorsstrongconvergenceinfiniteancillaregistermeasurement-free
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

This paper gives a denotational meaning to quantum while loops in a small measurement-free language, SL, whose only control flow is a loop on a qubit guard. The central claim is that even a loop that may run forever has a meaning as a bounded linear operator on the program's Hilbert space, defined as the strong limit of a sequence $L_n$ that accumulates exactly the branches where the guard has already become 0. This matters because it extends denotational semantics from measurement-based quantum control to coherent quantum-controlled iteration, and it formalizes the distinction between the terminating and the still-running parts of a computation. In the limit, a fully terminating loop has a denotation of norm 1 that agrees with the finite unitary approximations, while a fully divergent loop denotes the zero operator.

What carries the argument

The central object is the recursively defined family of operators $l_n(q,S) = (P0_{t_1}+P1_{t_1}\cdot S(l_{n-1}(q,S))\cdot S)\,G(q,1)$, where $S$ is the index shift $t_n\mapsto t_{n+1}$ on the infinite ancilla register and $G(q,1)$ is a CNOT that copies the guard qubit into a fresh ancilla at each iteration. The projector $P0_{t_1}$ selects the component where the guard has become 0 and accumulates it into the terminating part; $P1_{t_1}$ keeps the still-looping component computing on the next ancilla. This orthogonal-increment structure carries the argument: the differences $L_n - L_{n-1}$ act on disjoint ancilla subspaces, so their squared norms add and the partial sums form a bounded increasing sequence, which yields the Cauchy condition.

What would settle it

Take the program $\mathit{while}\,q\,\mathit{do}\{R_y(\theta)(q)\}$ on an input state with the guard in superposition and compute $\|L_n(q,R_y(\theta))|\psi\rangle\|$ for growing $n$. The paper predicts this norm converges to a limit between 0 and 1 for every $\theta$, because the squared norms of the orthogonal increments sum to a bounded monotone sequence; finding one angle $\theta$ for which those squared norms do not converge, or for which the limit norm is not reached, would refute the Cauchy argument. A second check is to show whether the shift map $S(G(q,n))=G(q,n+1)$ extends to a bounded linear operator on the infinite tensor product $H_T$; if it cannot, the recursive family $l_n$ has no well-defined base.

Watch

Extended reading notes

Core claim

The paper's central claim is that, for every program $s$ of SL, the unbounded quantum while statement $\mathit{while}\,q\,\mathit{do}\{s\}$ has a denotation in the Banach space of bounded linear operators on the program Hilbert space, given by $\llbracket \mathit{while}\,q\,\mathit{do}\{s\}\rrbracket = \lim_{n\to\infty} L_n(q,\llbracket s\rrbracket)$. Each finite approximation $L_n$ keeps only the component of the state in which the guard qubit has turned to 0 during the first $n$ iterations and discards the component that is still looping. The limit exists because the increments $L_n - L_{n-1}$ are mutually orthogonal bounded operators whose squared norms form a bounded increasing sequence, so the pointwise Cauchy condition of the strong-convergence theorem is satisfied. The resulting operator is a contraction; a loop that terminates on the whole input reaches norm 1, and a loop that diverges on the whole input is the zero operator.

Load-bearing premise

The construction rests on the assumption that an infinite supply of fresh ancilla qubits is available and that the index-shift operation $S$, which moves each iteration onto the next fresh qubit, is a well-defined bounded operator on the infinite program Hilbert space; no concrete implementation of $S$ is given in the paper.

Editorial extensions

If this is right

  • Every SL program, including a measurement-free while loop with unbounded iterations, receives a bounded linear denotation in $B(H_P)$, so reasoning about infinite quantum loops can proceed inside ordinary operator theory.
  • A loop that terminates on the whole input has denotation of norm 1 and coincides in the limit with the finite unitary circuit semantics; a loop that diverges on the whole input denotes the zero operator.
  • The linear denotation under-approximates the unitary one: it keeps exactly the branch in which the guard has turned false and drops the branch that is still running, exposing the terminating substate of a coherent computation.
  • The existence of the limit supplies a fixpoint for the while construct, so recursive quantum programs of this form can be given a semantics without importing a measurement-based probabilistic control flow.

Reading between the lines

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

  • Going beyond the paper: the squared norm of $\lim_n L_n(q,\llbracket s\rrbracket)|\psi\rangle$ is the probability, in the usual probabilistic rule of quantum mechanics, that the loop eventually terminates on $|\psi\rangle$, with the missing norm the divergence probability.
  • Going beyond the paper: the same strong-limit recipe could give a measurement-free denotational semantics for general quantum recursion by unfolding each recursive call on a fresh block of ancillas and taking the strong limit of the accumulating terminating branches.
  • Going beyond the paper: for a small loop such as $\mathit{while}\,q\,\mathit{do}\{H(q)\}$, one could truncate $L_n$ at finite $n$, turn it into a circuit, and measure the ancilla block; the squared amplitudes of the terminating branches would then be a direct experimental check of the predicted limiting distribution.
  • Going beyond the paper: to make the semantics implementable, one still needs an explicit bounded realization of the shift $S$ on the infinite tensor product, or a reformulation in a second-quantized state space; the paper does not supply that piece.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes a measurement-free quantum while language SL with unitary operations, sequential composition, skip, and quantum-controlled while loops. It first gives a finite unitary semantics W_n for bounded loops using an infinite ancilla register T, then defines a linear semantics in which a while loop is interpreted as the strong limit of operators L_n that collect only the terminating branches: ⟦while q do{s}⟧ = lim_n L_n(q,⟦s⟧). The paper claims that every SL program therefore receives a bounded linear denotation, that fully terminating loops have operator norm 1, that divergent loops yield the zero operator, and that this gives a denotational account of unbounded quantum loops without measurement.

Significance. If the construction were correct, it would be a useful contribution to the small literature on quantum control flow: it gives an explicit, circuit-oriented semantics for unbounded quantum loops, it separates terminating from non-terminating branches by a concrete limit construction, and it connects to existing work by Ying and by Badescu–Panangaden without claiming to solve the quantum halting problem. The paper is not circular: no data fitting, no parameter tuning, and the limit is an explicit construction rather than an existence claim. The main mathematical idea—approximating a non-convergent unitary sequence by a bounded linear sequence that keeps only terminating components—is natural and worth pursuing. However, the manuscript as written contains a compositionality defect for nested loops and an under-specified shift operator, both of which affect the central claim, so the contribution cannot be accepted in its present form.

major comments (4)
  1. [§5, Eq. (9), Eq. (10)] Nested loops break the fresh-ancilla assumption and make the semantics incorrect on a simple terminating program. Let B = while q do {X(q)} and consider P = while q do {B}. Operationally, P on |q=1> (with fresh ancillas) terminates with output norm 1: the inner loop flips q to 0 and then the outer guard is false. In the paper's semantics, however, the inner loop's denotation [B] is defined on the same ancilla register T, and when [B] acts on the intermediate state |q=1, t1=1, t2=0, ...> produced by the outer G(q,1), it returns |q=1, t1=0, t2=0, ...> rather than flipping q: the term P0_t1 G(q,1) in L_2(q,X) toggles t1 to 0 and leaves q unchanged. Consequently every term of the outer L_n(q,[B]) on |q=1, t1=0, ...> is annihilated by the bookkeeping projectors: the k=1 term fails because G(q,1) sets t1=1, and each k≥2 term fails because after [B] leaves q=1, the following G(q,k) toggles t_k and P0_tk kills the branch. Hence [P]|q=1> = 0, contradicting the paper's own claim that fully terminating loops receive a norm-1 denotation. The semantics is not compositional under nested loops unless fresh ancillas are explicitly allocated per loop invocation, which the language and Eq. (9) never do.
  2. [§4.1, Eq. (4) and §5, Eq. (9)] The shift operator S is never defined as a concrete bounded operator on H_P. The paper states only that 'S produces the shift t_n → t_{n+1}' and gives its action on G(q,n) and P_j,t_n, but H_T in Eq. (3) is an infinite tensor product of countably many qubits, and an index shift on a single one-sided infinite tensor product is not a unitary conjugation on that space (a unitary index shift would require a bi-infinite index set, or an isometric embedding rather than a surjective operator). Since S is used inside Eq. (9) and inside the products of Eq. (10), the entire limit construction depends on S being a well-defined bounded linear map on B(H_P). Proposition 5.2 also assumes, without stating the induction, that S(l_{i-1}(q,S))S is a contraction when restricted to the P1_t1 subspace; this needs a proof once S is made precise.
  3. [§5, Theorem 5.9] The written proof of Theorem 5.9 infers that {L_n|ψ>} is Cauchy from the fact that the consecutive differences tend to zero; this inference is not valid in general. The proof can be repaired using the material already present: Lemma 5.7 gives orthogonality of the increments, and the convergence of Σ ||(L_i-L_{i-1})|ψ>||², together with the Pythagorean equality, yields ||L_m|ψ> - L_n|ψ>||² = Σ_{i=n+1}^m ||(L_i-L_{i-1})|ψ>||² → 0. The authors should replace the final 'This ensures' step with that explicit argument; as written, the convergence theorem is not proved.
  4. [§6, Eq. (12)] The stated closed form for L_n(q,H_q) contains an index/amplitude error: the summation as printed writes 1/√(2^n) instead of the correct 1/√(2^i) (or an appropriate shift of index), and the earlier examples in Eq. (8) have a sign inconsistency for the n=0 case. These are presentation issues, but they obscure the intended convergence behavior and should be corrected.
minor comments (5)
  1. [Throughout] There are numerous typos and grammatical slips, e.g., 'copmputer', 'calssical', 'possibile', 'sobstitude', 'Shrödinger', 'writen', and stray punctuation such as ',.', which should be corrected before any further submission.
  2. [§3, grammar (1)] The grammar uses q both as a single qubit variable and as a sequence q1,...,qn, but the while construct requires a single guard; the paper should clarify whether a register can appear as a guard and how G(q,1) is defined for a multi-qubit register.
  3. [§4.1, Eq. (6)] The example while q do {skip} on |0...>_T |1>_q has ∥W_{n+1}|ψ> - W_n|ψ>∥ = 2, but the states shown are |1^{⊗n}0...>|1> and |1^{⊗(n+1)}0...>|1>, which are orthogonal and each has norm 1, so the distance is indeed √2, not 2. The displayed '2' appears to be a typo for √2.
  4. [§5, Proposition 5.10] The step from pointwise convergence on basis vectors to strong convergence on all vectors needs an explicit boundedness argument (or a citation to the Banach–Steinhaus theorem); the current 'therefore' is too quick.
  5. [§7] The related-work discussion is informative, but the claims about 'impossible to define a limit for the sequence of unitary operators' are only illustrated by examples, not proved for the general language; this should be stated more cautiously.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the limit construction is an explicit semantic definition, and the convergence argument is independent of the target denotation.

full rationale

The paper's central construction defines the while-loop denotation as lim_n L_n(q, [[s]]), where L_0(q,S)=0 is a stated convention meaning 'no terminating branch collected yet' and each L_n is built from the body semantics through controlled operations and projectors onto fresh ancillas. This is a direct, constructive definition of the denotation, not a quantity fitted to or extracted from the target result. The Cauchy-convergence proof (Theorem 5.9) relies on orthogonality of successive increments (Lemma 5.7) and monotonicity of partial sums (Lemma 5.8), which are proved independently from the recursion in Eq. (9); the boundedness argument in Proposition 5.2 is likewise an inductive norm estimate, not an assumption of the conclusion. There is no data fitting, no fitted parameter renamed as a prediction, and no self-citation chain is load-bearing: the citations to prior work by Selinger, Ying, and others are contextual and comparative, not used to justify the new limit operator. The choice l_0=0 is a semantic design decision, and the paper explicitly describes the linear semantics as an under-approximation collecting only terminating branches; this is the intended meaning, not a circularity. A possible concern about nested loops and the freshness of ancilla qubits is a soundness or compositionality issue, not a circularity, because it does not make the derived semantics equal to its inputs by construction.

Assumptions & free parameters 0 free parameters · 4 assumptions · 2 invented entities

The semantics rests on the infinite tensor product of ancillas, on the CNOT guard-copy trick, and on standard convergence theorems. No free parameters are fit to data. The invented entities are mathematical devices rather than physical postulates.

assumptions (4)
  • domain assumption The infinite tensor product H_T = ⊗_{t_i∈T} H_{t_i} over a countable set T is a Hilbert space with the standard basis, and the index shift on operators is a well-defined bounded operation.
    Used throughout Sections 4.1 and 5 to define w_n, L_n and the limit; no construction or reference for the infinite tensor product or the shift is given.
  • domain assumption The principle of deferred measurement allows measurement to be omitted from the language without loss of generality.
    Invoked in Section 3 to justify the absence of measurement; this is standard for finite circuits but is applied here to a language with loops and quantum control flow.
  • domain assumption Each loop iteration can copy the guard using a CNOT gate without altering the coherent evolution of the system.
    Figure 2b and Equation 4 rely on this; the paper notes self-controlled operations are non-unitary and uses ancillas to restore unitarity.
  • standard math Standard theorems: monotone bounded sequences of real numbers converge, and the Pythagorean theorem holds for sums of orthogonal vectors.
    Used in Theorem 5.9 and Lemma 5.7; these are cited to [9] and [6].
invented entities (2)
  • Infinite ancillary register T = {t_i}
    purpose: Fresh guard-copy qubit for each loop iteration, enabling representation of unbounded loops
    Mathematical device; no physical implementation or resource bound is discussed.
  • Shift operator S on the algebra of operators
    purpose: Reindexes operators from t_n to t_{n+1} so each iteration uses a fresh ancilla
    Needed for the recursion; its status as a bounded operator on the infinite tensor product is not established.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Denotational Semantics for Quantum Loops." pith.science (2026). https://pith.science/paper/D5J2QDNX

@misc{pith2026250623320,
  author       = {Pith},
  title        = {Pith review of: A Denotational Semantics for Quantum Loops},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/D5J2QDNX}},
  note         = {Machine review of arXiv:2506.23320}
}
read the original abstract

Programming a quantum computer, i.e., implementing quantum algorithms on a quantum processor-based copmputer architecture, is a task that can be addressed (just as for classical computers) at different levels of abstraction. This paper proposes a denotational semantics for high-level quantum programming constructs, focusing on the conceptual meaning of quantum-controlled branching and iteration. We introduce a denotational domain where a mathematical meaning of a quantum control flow with loops can be defined, which reflects the coherent evolution of the quantum system implementing the program.

Figures

Figures reproduced from arXiv: 2506.23320 by the authors.

Figure 1
Figure 1. The circuits corresponding to 𝑈 (𝑞) (a) and 𝑠1;𝑠2 (b). their Hilbert space: H𝑇 = Ì 𝑡𝑖 ∈𝑇 H𝑡𝑖 where H𝑡𝑖 = H2 (3) Finally, we call H𝑃 = H𝑇 ⊗ H𝑄𝑠 the Hilbert space of the program 𝑠. 4 UNITARY SEMANTICS A quantum language with no classical operations can be completely described by using unitary operators that can be visually represented by quantum circuits. A mathematical description of these circuits is by means of lin… view at source ↗
Figure 2
Figure 2. Quantum circuits for if𝑞 do {𝑈 (𝑞)} (a) and while 𝑞 do {𝑈 (𝑞)} (b) circuit representation of a quantum while loop, which is recursively defined and corresponds to an infinite composition of unitary operations on an infinite-dimensional Hilbert space. The first step in defining the semantics of a while loop is to start with the controlled operation. In general, consider a Hilbert space H = H𝑔 ⊗ H𝑠 , where H𝑔 is a 2-d… view at source ↗
Figure 3
Figure 3. Finite 𝑘-while loop The proof is given in Appendix A. Given a while 𝑞 do {𝑠} statement, we can build the chain of finite unitary approximation {W(𝑞, [𝑠 ]}𝑛. To define the semantics of the general construct, we must now consider the case of an infinite loop. However, we can show that there is no limit to this sequence. From [23], we recall the notion of strong convergence and an important theorem about the convergenc… view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: P := if𝑞 do {𝑈 (𝑞); P} circuit In his PhD thesis [2], Andrés-Martínez introduces a quantum while language similar to ours but equipped with a categorical semantics. The thesis extends Haghverdi’s unique decomposi￾tion categories—originally introduced to model iteration…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

31 extracted references · 22 canonical work pages

  1. [1]

    Altenkirch and J

    T. Altenkirch and J. Grattage. 2005. A functional quantum programming language. In 20th Annual IEEE Symposium on Logic in Computer Science (LICS’ 05) . 249–258. https://doi.org/10.1109/LICS.2005.1

    doi:10.1109/lics.2005.1 2005

  2. [2]

    Pablo Andrés-Martínez. 2022. Unbounded loops in quantum programs: categories and weak while loops.arXiv preprint arXiv:2212.05371 (2022)

    work page Pith review arXiv 2022

  3. [3]

    Costin Badescu and Prakash Panangaden. 2015. Quantum Alternation: Prospects and Problems. Proceedings 12th International Workshop on Quantum Physics and Logic, QPL 2015, Oxford, UK, July 15-17, 2015 195 (2015), 33–42. https://doi.org/10.4204/EPTCS.195.3

    doi:10.4204/eptcs.195.3 2015

  4. [4]

    Michel Baranger. 2003. Many-Body Problems and Quantum Field Theory: An Introduction. Physics To- day 56, 4 (04 2003), 69–70. https://doi.org/10.1063/1.1580057 arXiv:https://pubs.aip.org/physicstoday/article- pdf/56/4/69/11139124/69_1_online.pdf

    work page doi:10.1063/1.1580057 2003

  5. [5]

    Yuan Feng, Runyao Duan, Zhengfeng Ji, and Mingsheng Ying. 2007. Proof rules for the correctness of quantum programs. Theoretical Computer Science 386, 1 (2007), 151–166. https://doi.org/10.1016/j.tcs.2007.06.011

    work page doi:10.1016/j.tcs.2007.06.011 2007

  6. [6]

    Teiko Heinosaari and Mario Ziman. 2008. Guide to mathematical concepts of quantum theory. Acta Physica Slovaca 58, 4 (Aug. 2008), 487–674. https://doi.org/10.2478/v10155-010-0091-y arXiv:0810.3536 [quant-ph]

    work page Pith review arXiv 2008

  7. [7]

    Ginis, Michalis A

    Michael Lampis, Kyriakos G. Ginis, Michalis A. Papakyriakou, and Nikolaos S. Papaspyrou. 2008. Quantum Data and Control Made Easier. Electron. Notes Theor. Comput. Sci. 210 (July 2008), 85–105. https://doi.org/10.1016/j.entcs.2008. 04.020

    doi:10.1016/j.entcs.2008 2008

  8. [8]

    Noah Linden and Sandu Popescu. 1998. The halting problem for quantum computers. arXiv preprint quant-ph/9806054 (1998)

    work page Pith review arXiv 1998

Show all 31 references
  1. [9]

    A. Mattuck. 2013. Introduction to Analysis. CreateSpace Independent Publishing Platform. https://books.google.it/ books?id=mYppngEACAAJ

    2013

  2. [10]

    Takayuki Miyadera and Masanori Ohya. 2005. On Halting Process of Quantum Turing Machine. Open Systems & Information Dynamics 12, 3 (2005), 261–264. https://doi.org/10.1007/s11080-005-0923-2

    2005 doi

  3. [11]

    John M. Myers. 1997. Can a Universal Quantum Computer Be Fully Quantum?Phys. Rev. Lett. 78 (Mar 1997), 1823–1824. Issue 9. https://doi.org/10.1103/PhysRevLett.78.1823

    1997 doi

  4. [12]

    Nielsen and Isaac L

    Michael A. Nielsen and Isaac L. Chuang. 2010. Quantum Computation and Quantum Information: 10th Anniversary Edition. Cambridge University Press

    2010

  5. [13]

    S Perdrix. 2008. A hierarchy of quantum semantics. Electronic Notes in Theoretical Computer Science 192, 3 (2008), 71–83

    2008

  6. [14]

    Horn Roger and R Johnson Charles. 1991. Topics in matrix analysis

    1991

  7. [15]

    Amr Sabry, Benoît Valiron, and Juliana Kaizer Vizzotto. 2018. From Symmetric Pattern-Matching to Quantum Control. In Foundations of Software Science and Computation Structures . Springer International Publishing, 348–364. https://doi.org/10.1007/978-3-319-89366-2_19

    2018 doi

  8. [16]

    Peter Selinger. 2004. Towards a quantum programming language. Mathematical Structures in Computer Science 14, 4 (2004), 527–586. https://doi.org/10.1017/S0960129504004256

    2004 doi

  9. [17]

    V. S. Shchesnovich. 2013. The second quantization method for indistinguishable particles (Lecture Notes in Physics, UFABC 2010). arXiv:1308.3275 [cond-mat.quant-gas] https://arxiv.org/abs/1308.3275

    2013 arXiv

  10. [18]

    Yu Shi. 2002. Remarks on universal quantum computer. Physics Letters A 293, 5 (2002), 277–282. https://doi.org/10. 1016/S0375-9601(02)00015-4

    2002

  11. [19]

    Daegene Song. 2008. Unsolvability of the halting problem in quantum dynamics. International Journal of Theoretical Physics 47 (2008), 1785–1791

    2008

  12. [20]

    Michael Spivak. 2008. Calculus (fourth ed.). Publish or Perish

    2008

  13. [21]

    Joseph E. Stoy. 1981. Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory . MIT Press, Cambridge, MA, USA

    1981

  14. [22]

    Benoît Valiron. 2022. Semantics of quantum programming languages: Classical control, quantum control. Journal of Logical and Algebraic Methods in Programming 128 (2022), 100790. https://doi.org/10.1016/j.jlamp.2022.100790

    2022

  15. [23]

    Paolo Vanini. 2017. Functional Analysis. Chapter XII Convergence in Infinite Dimensional Spaces. https://www. researchgate.net/publication/319618010_Functional_Analysis_XII_Convergence_in_Infinite_Dimensional_Spaces

    2017

  16. [24]

    Mingsheng Ying. 2012. Floyd–hoare logic for quantum programs. ACM Trans. Program. Lang. Syst. 33, 6, Article 19 (January 2012), 49 pages. https://doi.org/10.1145/2049706.2049708

    2012

  17. [25]

    Mingsheng Ying. 2014. Quantum recursion and second quantisation. arXiv preprint arXiv:1405.4443 (2014)

    2014 arXiv

  18. [26]

    Mingsheng Ying. 2016. Foundations of quantum programming . Morgan Kaufmann

    2016

  19. [27]

    Mingsheng Ying and Yuan Feng. 2010. Quantum loop programs. Acta Informatica 47, 4 (2010), 221–250

    2010

  20. [28]

    Mingsheng Ying, Nengkun Yu, and Yuan Feng. 2012. Defining Quantum Control Flow. CoRR abs/1209.4379 (2012). arXiv:1209.4379 http://arxiv.org/abs/1209.4379 A Denotational Semantics for Quantum Loops 15

    2012 arXiv

  21. [29]

    Mingsheng Ying, Nengkun Yu, and Yuan Feng. 2014. Alternation in Quantum Programming: From Superposition of Data to Superposition of Programs. CoRR abs/1402.5172 (2014). arXiv:1402.5172 http://arxiv.org/abs/1402.5172

    2014 arXiv

  22. [30]

    Charles Yuan, Agnes Villanyi, and Michael Carbin. 2024. Quantum Control Machine: The Limits of Control Flow in Quantum Programming. Proc. ACM Program. Lang. 8, OOPSLA1, Article 94 (April 2024), 28 pages. https: //doi.org/10.1145/3649811

    2024 doi

  23. [31]

    Zhicheng Zhang and Mingsheng Ying. 2024. Quantum Register Machine: Efficient Implementation of Quantum Recursive Programs. arXiv:2408.10054 [quant-ph] https://arxiv.org/abs/2408.10054 A OMITTED PROOFS Proposition 4.3. The closed formula of Equation 4, is: W𝑛(𝑞,𝑆) = 𝑛∑︁ ℎ=1 ( ℎ...

    2024 arXiv

Pith tools

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