Pith. sign in

REVIEW 4 major objections 6 minor 32 references

Advancing Quantum State Preparation Using Decision Diagram with Local Invertible Maps

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

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

Pith's one-line read Quantum state preparation circuits can be synthesized directly from a compact decision diagram whose edges carry local invertible maps, so circuit size and runtime scale with the diagram's reduced paths rather than with the full state…

desk verdict Sound algorithmic construction with real potential for structured states; the scalability claims outrun the experiments, which only cover Clifford+T-generated states. read the letter →

arxiv 2507.17170 v2 pith:UGFNCHVO submitted 2025-07-23 cs.DS quant-ph

Xin Hong , Aochu Dai , Chenjian Li , Sanjiang Li , Shenggang Ying , Mingsheng Ying This is my paper
classification cs.DSquant-ph MSC 68Q1281P68
keywords quantumstatepreparationLimTDDlocalinvertiblemapsdecisiondiagramsXP-stabilizersancillaqubitscircuitsynthesisgatecomplexity
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

Quantum state preparation can be made much cheaper, the paper argues, by first compressing a target state into a LimTDD—a decision diagram whose edges carry local invertible maps—and then reading a circuit directly off the diagram. The paper gives four synthesis algorithms, for zero, one, many, and an arbitrary number of ancilla qubits. Each algorithm cancels the operator weights on the diagram's edges from the top down and then collapses the remaining complex weights from the bottom up. Since synthesis time and circuit size scale with the number of reduced paths and diagram nodes rather than with the $2^n$-dimensional state vector, any state with exploitable structure becomes cheaper to prepare. On structured benchmark states the measured circuits are far smaller than those produced by the standard baselines, with an exponential gap in best cases.

What carries the argument

The central object is the Local Invertible Map Tensor Decision Diagram (LimTDD), a rooted directed acyclic graph in which each edge carries a local invertible map—a tensor product of single-qubit $X$ and diagonal phase operators (XP-stabilizers) times a complex scale. This lets isomorphic subtrees be merged even when they differ by local unitary factors, which is what compresses the state. The argument is carried by three basic constructions: eliminate the operator on the incoming edge by applying its inverse; eliminate a high-edge operator by a controlled inverse gate whose control is the branch condition of the path; and reduce a node's two outgoing complex weights to $[1,0]$ by a controlled unitary. The quantities that set the complexity are the number of reduced paths—paths in the diagram after merging equal successor edges—and the number of nonterminal nodes.

What would settle it

Generate $n$-qubit target states with no exploitable structure, for instance by drawing their amplitudes from the uniform (Haar) measure or from deep random circuits, and plot the LimTDD node count, synthesis time, and transpiled gate count against $n$. If those quantities grow like $2^n$—matching or exceeding the general QSP cost—then the scalable speedup is specific to structured states rather than to large-scale states in general. A cheaper check is to record the LimTDD size distribution across the 20 random Clifford+T states sampled per size in the paper; a wide spread would show that the reported averages are not yet stable estimates.

Watch

Extended reading notes

Core claim

On its own terms, the paper's central claim is that quantum state preparation reduces to a diagram-transformation task: apply the inverse of a circuit that the LimTDD itself defines, and the target state collapses to $\lvert 0\rangle^{\otimes n}$. Each node contributes one controlled rotation that reduces its two outgoing edge weights to $[1,0]$, and each nontrivial edge operator contributes one controlled inverse gate. The four algorithms differ mainly in how those controls are implemented and in how many ancillas are used. With no ancilla, every cancellation is guarded by the branch condition, giving time $O(np)$ for $p$ reduced paths, or $O(m)$ with memoization. With one ancilla, the ancilla qubit marks the currently open node and removes many control qubits from the gates. With one ancilla per nonterminal node, a breadth-first pass marks each node open and closed using CCX gates, and the time drops to $O(m)$. The gate-count bounds are written in terms of $p$, $m$, and $n$, so the whole strategy is: compress the diagram, and the circuit shrinks with it.

Load-bearing premise

The load-bearing premise is that states sampled from random Clifford+T circuits represent the large-scale quantum states users actually need; if real target states are less structured, the LimTDD grows exponentially and the reported gate and runtime advantages shrink or disappear.

Editorial extensions

If this is right

  • A state whose LimTDD has only $p$ reduced paths is prepared with a circuit whose gate count is bounded in terms of $p$ and $n$, so the preparation cost tracks the diagram's compression rather than the $2^n$-dimensional state vector.
  • The no-ancilla algorithm runs in $O(np)$ time, or $O(m)$ with a cache, and the sufficient-ancilla algorithm runs in $O(m)$ time, where $m$ is the number of nonterminal nodes.
  • More available ancilla qubits make the synthesized circuits smaller and the runtime more predictable; with many ancillas the algorithm uses only CCX and small controlled gates.
  • For tower-form diagrams, where all nonterminal nodes have identical successors, the circuit reduces to $O(n)$ single-qubit gates and $O(n^2)$ two-qubit gates.
  • In best-case scenarios, where the LimTDD achieves exponential compression over a conventional state vector, the resulting preparation circuit is exponentially smaller than the gate counts of the standard no-ancilla baselines.

Reading between the lines

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

  • A direct consequence the paper leaves implicit: any tensor network that the LimTDD can compress well—not just the Clifford+T benchmark states—should inherit the same preparation shortcut, so the method is a bridge between tensor-network structure and circuit synthesis.
  • The ancilla-saving encoding that addresses branch nodes with $\lceil\log m\rceil+1$ qubits trades ancilla count against extra control qubits per gate; the paper gives no automatic rule for choosing the operating point, so a resource-adaptive variant is a natural extension.
  • The exponential improvement is a statement about compression, not about worst-case quantum state preparation; for unstructured states the exponential lower bound remains, so the practical reach of the method is exactly the class of states with small LimTDDs.
  • A testable extension: run the algorithms on states with known tensor-network structure from quantum chemistry or data encoding; if the gate count tracks LimTDD size there too, the method's usefulness extends well beyond the paper's Clifford+T benchmarks.
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

4 major / 6 minor

Summary. The paper proposes four quantum state preparation (QSP) algorithms built on Local Invertible Map Tensor Decision Diagrams (LimTDDs): Algorithm 1 with no ancilla qubits, Algorithm 2 with one ancilla qubit, Algorithm 3 with one ancilla qubit per non-terminal node, and Algorithm 4 with an optional number of ancillas. All four follow a common scheme: eliminate the operator on the incoming edge, eliminate high-edge operators top-down using controlled unitary gates, and then reduce outgoing weights bottom-up. The paper states time complexities of O(np) for Algorithms 1 and 2 and O(m) for Algorithm 3, with gate counts expressed in terms of reduced paths p and non-terminal nodes m. Experiments on random Clifford+T states up to n=15 qubits compare the methods with Qiskit, QuICT, an ADD-based method, and an FBDD-based method, reporting large reductions in runtime and gate counts. The central claim is that LimTDD compactness translates into substantially smaller QSP circuits, with exponential improvement in best-case scenarios.

Significance. If the algorithmic content is sound, this is a useful contribution: it extends decision-diagram-based QSP to LimTDD, provides a family of methods with different ancilla trade-offs, and includes an open-source implementation with detailed worked examples. The complexity statements are parameter-free with respect to the input LimTDD, and the algorithm family is a natural extension of prior work on ADD- and FBDD-based preparation. The main caveat is that the practical advantage depends entirely on LimTDD compactness for the target states, and the experimental evidence for that compactness is narrow. The paper also relies on the companion LimTDD paper [28] for the representation's compression properties, so the contribution is incremental relative to that companion work while still being nontrivial.

major comments (4)
  1. [Section VIII, first paragraph] The experiments use only 20 random states per n generated by Clifford+T circuits, for n up to 15, and report no error bars or variance. This is a single family that is favorable to decision-diagram methods, since states generated by low-depth Clifford+T circuits have compact LimTDDs by construction. The abstract and conclusion claim better scalability for "large-scale quantum states" in general, but if application states (e.g., QML data encodings, chemistry states, or sparse states) have near-maximal LimTDD size, the advantage over Qiskit and QuICT disappears. Please either benchmark additional state families that are representative of the target applications, or qualify the scalability claim to states with compact LimTDD representations.
  2. [Section III-B, Definitions 3-4] The sufficiency of the branch condition is justified by a single example. All four algorithms rely on the assertion that controlling on branch-node values alone addresses the node under consideration without affecting orthogonal parts, even when nodes are shared, when the accumulated weight along a prefix path may be non-scalar, and when ancestor high-edge operators have not yet been eliminated. Provide a formal invariant for the recursive controlled-subcircuit construction (e.g., for Algorithm 1) proving that after the high-edge elimination steps, every computational basis state in the support of a node has the same branch condition and a scalar accumulated weight.
  3. [Sections IV-C, V-C, VI-C] The complexity bounds are stated as bullet lists with no derivation. For instance, the claim that Algorithm 1 uses p(n+2-s) s-qubit gates presupposes an exact accounting of multi-controlled gates per reduced path and does not explain how node caching (which gives the O(m) time bound) interacts with the gate count of the final circuit. The O(np) time claim also assumes every reduced path contains n non-terminal nodes, which is not justified for a DAG with shared nodes. Please provide concrete counting arguments or proofs for the stated time and gate bounds.
  4. [Algorithm 2 pseudocode, lines 12 and 15] The recursive calls STATEPRE2(low(v), qa, p0) and STATEPRE2(high(v), qa, p1) use p0 and p1, but these are never defined in the pseudocode. Since the branch condition is essential to correctness and to the complexity statement, the algorithm as printed is not directly implementable. Define p0 and p1 explicitly (e.g., p extended by the branch value of v) and state how non-branch nodes are treated in these recursive calls.
minor comments (6)
  1. [Section I] The structure sentence 'From section VI to IV' appears to have reversed section numbers; the paper actually discusses sections IV through VII.
  2. [Algorithm 4, line 17] The line 'End For Loop if u is the terminal node' is not meaningful pseudocode; it should be a 'continue' or 'skip this iteration' statement.
  3. [Figures 3, 5, 7, and 8] The captions refer to nodes 'y1' and 'y′1', but the LimTDDs in the figures use labels v00, v01, v10, v11, and v20; please align the notation.
  4. [Section II-C] There are several typos: 'For convience', 'we use will |∗⟩n to represent', and the phrase 'If we ignore...' in Example 2 should be cleaned up.
  5. [Section VIII] The sentence 'QuICT–which to not utilise ancilla qubits' has a typo ('to not' should be 'does not').
  6. [Section IV-C] The bound 'p(n+2-s) s-qubit gates' should make explicit that it means p·(n+2−s) gates for each s, and clarify the range of s (2 ≤ s ≤ n).

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the QSP synthesis is self-contained given a LimTDD; the compactness premise is prior published work with an independent implementation, not an assumption embedded in the derivation.

full rationale

The paper's derivation chain is constructive rather than definitional. Algorithms 1-4 take a LimTDD representing the target state and eliminate edge operators (Basic Constructions 1-2) and outgoing weights (Basic Construction 3), producing a circuit U with U|ψ⟩=|0⟩. The stated complexity bounds O(np), O(m), and the gate-count bounds are obtained by counting recursive visits and controlled gates over the input diagram; they do not fit any parameter to the outputs they claim to predict. The experimental comparisons with Qiskit, QuICT, ADD- and FBDD-based methods are external benchmarks whose outcomes are not forced by the algorithms' construction. The paper does rely on the compactness of LimTDD, citing the authors' prior work [28] and the ICCAD precursor [30]; however, that compactness is a property of a published, code-backed data structure and does not assume the QSP circuit-size result derived here. No equation in the paper reduces to its own input, and no fitted value is renamed as a prediction. Hence no circular step can be exhibited, and the appropriate finding is no significant circularity.

Assumptions & free parameters 0 free parameters · 5 assumptions · 0 invented entities

No free parameters are fitted: all rotation angles c = w1/w0 are determined by the input state. No new physical entities are introduced; LimTDD and XP-stabilizers are taken from the authors' prior work [28] and treated as given. The main assumptions are about the normalized form of the input diagram and the sufficiency of branch conditions.

assumptions (5)
  • domain assumption The input LimTDD is normalized: each non-terminal node has low edge weight I and high edge weight lambda*O (Section III, before Complexity).
    Constructions 2 and 3 require this form; deviation would require additional normalization steps not analyzed in the complexity bounds.
  • domain assumption LimTDD semantics correctly represent the target quantum state (Definition 2).
    The algorithms operate on the graph structure; if the representation were unsound, the synthesized circuits would not prepare the target state.
  • ad hoc to paper The branch condition, using only branch-node values as controls, is sufficient to address a node without affecting orthogonal parts of the state (Section III-B).
    Given by example rather than a general theorem; the algorithm relies on this simplification to reduce control qubit counts, and its correctness is not fully proven.
  • domain assumption Elementary gates (controlled rotations, multi-controlled X) are available in the compiled gate set with the stated costs (Sections IV-C and VIII).
    Gate complexity bounds count each multi-controlled gate as one unit before transpilation; the experiments then transpile to CX and single-qubit gates, assuming standard decompositions.
  • standard math For arbitrary n-qubit states, exact preparation requires exponential resources (Section I).
    This is the background lower bound; the claimed improvements are for structured states that LimTDD can represent compactly.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Advancing Quantum State Preparation Using Decision Diagram with Local Invertible Maps." pith.science (2026). https://pith.science/paper/UGFNCHVO

@misc{pith2026250717170,
  author       = {Pith},
  title        = {Pith review of: Advancing Quantum State Preparation Using Decision Diagram with Local Invertible Maps},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/UGFNCHVO}},
  note         = {Machine review of arXiv:2507.17170}
}
read the original abstract

Quantum state preparation (QSP) is a fundamental task in quantum computing and quantum information processing. It is critical to the execution of many quantum algorithms, including those in quantum machine learning. In this paper, we propose a family of efficient QSP algorithms tailored to different numbers of available ancilla qubits - ranging from no ancilla qubits, to a single ancilla qubit, to a sufficiently large number of ancilla qubits. Our approach exploits the power of Local Invertible Map Tensor Decision Diagrams (LimTDDs) - a highly compact representation of quantum states that combines tensor networks and decision diagrams to reduce quantum circuit complexity. Extensive experiments demonstrate that our methods significantly outperform existing approaches and exhibit better scalability for large-scale quantum states, both in terms of runtime and gate complexity. Furthermore, our method shows exponential improvement in best-case scenarios.

Figures

Figures reproduced from arXiv: 2507.17170 by the authors.

Figure 1
Figure 1. Example of a quantum circuit with Hadamard and [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. An example of LimTDD representing the quantum state [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The quantum circuit that transforms the quantum state [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: An example of Multiple-terminal ADD [25] representing the quantum [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: The quantum circuit that transforms the quantum state [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: An example of FBDD [26] representing the quantum state [PITH_FULL_IMAGE:figures/full_fig_p009_6.png]
Figure 7
Figure 7. Figure 7: The quantum circuit that transforms the quantum state [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 8
Figure 8. Figure 8: The quantum circuit that transforms the quantum state [PITH_FULL_IMAGE:figures/full_fig_p013_8.png]
Figure 9
Figure 9. Figure 9: Experiment results of the Alg. 1, compared with QuICT and Qiskit. [PITH_FULL_IMAGE:figures/full_fig_p015_9.png]
Figure 10
Figure 10. Figure 10: Experiment results of our method against ADD-based method [25]. [PITH_FULL_IMAGE:figures/full_fig_p015_10.png]
Figure 11
Figure 11. Figure 11: Experiment results of our method (Alg. 3) against FBDD-based method [26] implemented in TDD. [PITH_FULL_IMAGE:figures/full_fig_p015_11.png]
Figure 12
Figure 12. Figure 12: Compare with other ancilla-based LimTDD algorithms. [PITH_FULL_IMAGE:figures/full_fig_p017_12.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

32 extracted references · 20 canonical work pages

  1. [28]

    LimTDD: A Compact Decision Diagram Integrating Tensor and Local Invertible Map Representations,

    X. Hong, A. Dai, D. Gao, S. Li, Z. Ji, and M. Ying, “LimTDD: A Compact Decision Diagram Integrating Tensor and Local Invertible Map Representations,” Apr. 2025, arXiv:2504.01168 [cs]. [Online]. Available: http://arxiv.org/abs/2504.01168

    arXiv 2025

  2. [1]

    Algorithms for quantum computation: discrete logarithms and factoring,

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

    work page 1994

  3. [2]

    Quantum computational chemistry,

    S. McArdle, S. Endo, A. Aspuru-Guzik, S. C. Benjamin, and X. Yuan, “Quantum computational chemistry,” Reviews of Modern Physics , vol. 92, no. 1, p. 015003, 2020

    2020

  4. [3]

    Quantum machine learning,

    J. Biamonte, P. Wittek, N. Pancotti, P. Rebentrost, N. Wiebe, and S. Lloyd, “Quantum machine learning,” Nature, vol. 549, no. 7671, pp. 195–202, 2017

    2017

  5. [4]

    Quantum algorithm for linear systems of equations,

    A. W. Harrow, A. Hassidim, and S. Lloyd, “Quantum algorithm for linear systems of equations,” Physical review letters , vol. 103, no. 15, p. 150502, 2009

    2009

  6. [5]

    An efficient algorithm for sparse quantum state preparation,

    N. Gleinig and T. Hoefler, “An efficient algorithm for sparse quantum state preparation,” in 2021 58th ACM/IEEE Design Automation Confer- ence (DAC). IEEE, 2021, pp. 433–438

    work page 2021

  7. [6]

    Toward optimal circuit size for sparse quantum state preparation,

    R. Mao, G. Tian, and X. Sun, “Toward optimal circuit size for sparse quantum state preparation,” Physical Review A , vol. 110, no. 3, p. 032439, 2024

    work page 2024

  8. [7]

    Simple quantum algorithm to efficiently prepare sparse states,

    D. Ramacciotti, A. I. Lefterovici, and A. F. Rotundo, “Simple quantum algorithm to efficiently prepare sparse states,” Phys. Rev. A , vol. 110, p. 032609, Sep 2024. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevA.110.032609

    doi:10.1103/physreva.110.032609 2024

Show all 32 references
  1. [8]

    Space-time tradeoff for sparse quantum state preparation,

    J. Luo, G. Li, and L. Li, “Space-time tradeoff for sparse quantum state preparation,” arXiv preprint arXiv:2506.16964 , 2025

    2025 arXiv

  2. [9]

    Nearly optimal circuit size for sparse quantum state preparation,

    L. Li and J. Luo, “Nearly optimal circuit size for sparse quantum state preparation,” arXiv preprint arXiv:2406.16142 , 2024

    2024

  3. [10]

    Quantum-state preparation with universal gate decompositions,

    M. Plesch and C. Brukner, “Quantum-state preparation with universal gate decompositions,” Physical Review A , vol. 83, no. 3, p. 032302, Mar 2011. [Online]. Available: https://journals.aps.org/pra/abstract/10. 1103/PhysRevA.83.032302

    2011

  4. [11]

    Synthesis of quantum-logic circuits,

    V . Shende, S. S. Bullock, S. S. Bullock, and I. L. Markov, “Synthesis of quantum-logic circuits,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems , 2006

    2006

  5. [12]

    Quantum circuits for isometries,

    R. Iten, R. Colbeck, I. Kukuljan, J. Home, and M. Christandl, “Quantum circuits for isometries,” Physical Review A , Mar 2016. [Online]. Available: http://dx.doi.org/10.1103/physreva.93.032318

    2016 doi

  6. [13]

    Transformation of quantum states using uniformly controlled rotations,

    M. Mottonen, J. J. Vartiainen, V . Bergholm, and M. M. Salomaa, “Transformation of quantum states using uniformly controlled rotations,” arXiv preprint quant-ph/0407010 , 2004

    2004 arXiv

  7. [14]

    A divide- and-conquer algorithm for quantum state preparation,

    I. F. Araujo, D. K. Park, F. Petruccione, and A. J. da Silva, “A divide- and-conquer algorithm for quantum state preparation,” Scientific reports, vol. 11, no. 1, p. 6329, 2021

    2021

  8. [15]

    Quantum circuits with uniformly controlled one-qubit gates,

    V . Bergholm, J. J. Vartiainen, M. Mottonen, and M. M. Salomaa, “Quantum circuits with uniformly controlled one-qubit gates,” Physical Review A , vol. 71, no. 5, p. 052330, May 2005. [Online]. Available: https://journals.aps.org/pra/abstract/10.1103/PhysRevA.71.052330

    2005 doi

  9. [16]

    Quantum state preparation with op- timal circuit depth: Implementations and applications,

    X.-M. Zhang, T. Li, and X. Yuan, “Quantum state preparation with op- timal circuit depth: Implementations and applications,” Physical Review Letters, vol. 129, no. 23, p. 230504, 2022

    2022

  10. [17]

    Spacetime-efficient low-depth quantum state preparation with applica- tions,

    K. Gui, A. M. Dalzell, A. Achille, M. Suchara, and F. T. Chong, “Spacetime-efficient low-depth quantum state preparation with applica- tions,” Quantum, vol. 8, p. 1257, 2024

    2024

  11. [18]

    Low-depth quantum state preparation,

    X.-M. Zhang, M.-H. Yung, and X. Yuan, “Low-depth quantum state preparation,” Physical Review Research, vol. 3, no. 4, p. 043200, 2021

    2021

  12. [19]

    Asymptotically optimal circuit depth for quantum state preparation and general unitary synthesis,

    X. Sun, G. Tian, S. Yang, P. Yuan, and S. Zhang, “Asymptotically optimal circuit depth for quantum state preparation and general unitary synthesis,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems , vol. 42, no. 11, pp. 3301–3314, 2023

    2023

  13. [20]

    Bdd-based synthesis of reversible logic for large functions,

    R. Wille and R. Drechsler, “Bdd-based synthesis of reversible logic for large functions,” in 2009 46th ACM/IEEE Design Automation Confer- ence, 2009, pp. 270–275

    2009

  14. [21]

    Polynomial circuit verification using bdds,

    R. Drechsler, “Polynomial circuit verification using bdds,” in 2021 5th International Conference on Electrical, Electronics, Communication, Computer Technologies and Optimization Techniques (ICEECCOT) , 2021, pp. 49–52

    2021

  15. [22]

    QCEC: A JKQ tool for quantum circuit equivalence checking,

    L. Burgholzer and R. Wille, “QCEC: A JKQ tool for quantum circuit equivalence checking,” Software Impacts, vol. 7, p. 100051, 2021

    2021

  16. [23]

    Quantum circuit simulation with fast tensor decision diagram,

    Q. Zhang, M. Saligane, H.-S. Kim, D. Blaauw, G. Tzimpragos, and D. Sylvester, “Quantum circuit simulation with fast tensor decision diagram,” in 2024 25th International Symposium on Quality Electronic Design (ISQED), 2024, pp. 1–8

    2024

  17. [24]

    Automatic uniform quantum state preparation using decision diagrams,

    F. Mozafari, M. Soeken, H. Riener, and G. De Micheli, “Automatic uniform quantum state preparation using decision diagrams,” in 2020 IEEE 50th International Symposium on Multiple-Valued Logic (ISMVL) . IEEE, 2020

    2020

  18. [25]

    Efficient deterministic preparation of quantum states using decision diagrams,

    F. Mozafari, G. De Micheli, and Y . Yang, “Efficient deterministic preparation of quantum states using decision diagrams,” Phys. Rev. A , vol. 106, p. 022617, Aug 2022. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevA.106.022617

    2022 doi

  19. [26]

    Quantum state preparation via free binary decision diagram,

    Y . Tanaka, H. Yamasaki, and M. Murao, “Quantum state preparation via free binary decision diagram,” 2024. [Online]. Available: https: //arxiv.org/abs/2407.01671 Fig. 12. Compare with other ancilla-based LimTDD algorithms

    2024 arXiv

  20. [27]

    LIMDD: A decision diagram for simulation of quantum computing including stabilizer states,

    L. Vinkhuijzen, T. Coopmans, D. Elkouss, V . Dunjko, and A. Laarman, “LIMDD: A decision diagram for simulation of quantum computing including stabilizer states,” Quantum, vol. 7, p. 1108, 2023

    2023

  21. [29]

    A tensor network based decision diagram for representation of quantum circuits,

    X. Hong, X. Zhou, S. Li, Y . Feng, and M. Ying, “A tensor network based decision diagram for representation of quantum circuits,” ACM Transactions on Design Automation of Electronic Systems (TODAES) , vol. 27, no. 6, pp. 1–30, 2022

    2022

  22. [30]

    Quantum state preparation based on LimTDD,

    X. Hong, C. Li, A. Dai, S. Li, S. Ying, and M. Ying, “Quantum state preparation based on LimTDD,” in 2025 IEEE/ACM International Conference On Computer Aided Design (ICCAD) , 2025, pp. 1–8

    2025

  23. [31]

    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

  24. [32]

    QuICT: Quantum Computer of Institute of Computing Technology,

    Institute of Computing Technology, Chinese Academy of Sciences, “QuICT: Quantum Computer of Institute of Computing Technology,” https://quict-docs.readthedocs.io/aa/latest/, 2023

    2023

Pith tools

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