Pith. sign in

REVIEW 3 major objections 5 minor 35 references

Quantum Gate Decomposition: A Study of Compilation Time vs. Execution Time Trade-offs

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

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

Pith's one-line read This paper claims that, in a single-platform implementation, the Network decomposition produces the fewest CNOT gates and the shallowest circuits for every class of multi-controlled gate, and that the remaining algorithms sort into two…

desk verdict A useful, honest benchmark of known decomposition algorithms in a single platform, but the proposed 'compilation time' and 'execution time' profiles are built on unvalidated proxies (CNOT count and depth) that need either validation or softer naming. read the letter →

arxiv 2504.20291 v2 pith:WXWFFBD3 submitted 2025-04-28 quant-ph cs.PL

Evandro C. R. Rosa , Jerusa Marchi , Eduardo I. Duzzioni , Rafael de Santiago This is my paper · ORCID
classification quant-phcs.PL
keywords quantumcomputingcompilationgatedecompositionmulti-controlledgatesCNOTcountcircuitdepthprofilesauxiliaryqubits
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

The paper sets out to make the first step of quantum compilation—decomposing multi-qubit gates into one- and two-qubit operations—a data-driven choice rather than a guess. It implements the state-of-the-art decomposition algorithms inside the Ket quantum programming platform and benchmarks them on multi-controlled Pauli, rotation, and phase/Hadamard gates. The central claim is that the Network decomposition is the most efficient algorithm across all gate types, and that the other algorithms can be ranked into two compilation profiles: one favoring few CNOT (two-qubit) gates as a proxy for fast compilation, and one favoring shallow CNOT depth as a proxy for fast execution. If the ranking is right, compiler writers can pick a decomposition strategy by gate type, auxiliary-qubit budget, and whether they are compiling for near-term machines or for large-scale fault-tolerant ones.

What carries the argument

The load-bearing object is the decomposition circuit itself: each algorithm is a concrete rewrite rule that expands one $n$-controlled single-qubit gate into a pattern of CNOTs and single-qubit rotations, and the paper measures the pattern's cost in CNOT count and in CNOT-only circuit depth. The key identity inside these patterns is the relative-phase Toffoli approximation (the C2X and C3X constructions), which lets a multi-controlled gate be assembled from blocks of $O(\log n)$ depth. The benchmark instrument is a single compiler that applies any of these rewrites to the same source instruction while automatically allocating clean or dirty auxiliary qubits, which is what makes the comparison across algorithms consistent.

What would settle it

Run the same decomposition algorithms with actual clock-based compilation timings and hardware execution timings (or a cycle-accurate simulation) on multi-controlled gates with 100 to 2000 control qubits; if the algorithm ranked first in Table 2 is not the fastest in practice, the CNOT-count and CNOT-depth proxies fail.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that the choice among decomposition algorithms can be settled empirically rather than left to asymptotic intuition. In the unified Ket implementation, the Network decomposition is the most efficient algorithm across all gate types—lowest CNOT count and lowest depth—but it demands the most clean auxiliary qubits. The benchmark data also show that clean auxiliary qubits outperform dirty ones by a wide margin, with the Single Aux Linear algorithm as an exception, and that logarithmic-depth algorithms only win in very large circuits, beyond about 1000 qubits. These observations are condensed into two profile rankings: a Compilation Time profile for minimizing CNOT count and an Execution Time profile for minimizing circuit depth counting only CNOTs.

Load-bearing premise

The ranking rests on treating the number of CNOT (two-qubit) gates as a faithful proxy for how long compilation takes, and the depth of those CNOTs as a faithful proxy for how long the quantum circuit runs; the paper assumes this equivalence rather than testing it against real timings.

Editorial extensions

If this is right

  • A compiler following the Compilation Time profile will use Network C2X or C3X whenever enough clean auxiliaries exist, producing the smallest CNOT counts among the surveyed methods.
  • A compiler targeting large-scale fault-tolerant machines should follow the Execution Time profile, where Network variants dominate and Single Aux Log is the best single-auxiliary option for Pauli gates.
  • Because clean auxiliaries sharply improve both metrics over dirty ones, having roughly double the qubits needed by the program can dramatically reduce both compilation and execution cost.
  • Linear Depth remains the crucial no-auxiliary fallback for most gate types, so near-term compilers should keep it, though its relevance may decline as more qubits become available.
  • The benchmark data can be arranged into a lookup table that selects the best decomposition for a given gate type and control count below 2200 qubits, where performance is not easily predictable from asymptotics.

Reading between the lines

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

  • My inference: the paper's profiles are really circuit-quality profiles, not end-to-end performance profiles, because routing, pulse scheduling, and single-qubit gate costs could reorder the table on specific hardware.
  • My inference: a direct test of the proxy assumption would be to repeat the benchmark using actual wall-clock compilation times and hardware execution times rather than CNOT counts and CNOT depth.
  • My inference: the same single-platform methodology could be extended to non-Clifford gates, where quantum error correction overhead may change which decomposition is cheapest in practice.
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

3 major / 5 minor

Summary. The paper addresses the first step of quantum compilation, the decomposition of multi-qubit gates into one- and two-qubit gates, within the Ket quantum programming platform. It surveys and implements a set of decomposition algorithms for Pauli, rotation, and phase/Hadamard gates, and reports benchmark data on CNOT count and CNOT-only circuit depth as proxies for compilation time and execution time. Based on the resulting rankings, it proposes two compilation profiles: one for minimizing compilation time and one for minimizing quantum execution time, summarized in Table 2. The central result is that the Network decomposition with approximate C2X/C3X gates ranks first in both profiles across all gate families, provided clean auxiliary qubits are available.

Significance. If the proxy assumption were empirically supported, the paper would be a useful engineering comparison; its single-platform implementation of many decomposition algorithms is a genuine contribution, and the artifact is deposited at Zenodo. The explicit acknowledgement of hardware-dependent effects (Section 7) and the absence of any wall-clock or hardware execution measurement mean, however, that the headline profiles are not established for the quantities they claim to minimize. The paper is likely to be useful to compiler developers as an organized comparison of CNOT counts and depths, but the two 'time' profiles are not yet a reliable basis for compiler decisions.

major comments (3)
  1. [Section 5 (Algorithms Benchmark), also Section 2] The paper equates compilation time with the number of CNOTs and execution time with the circuit depth computed over CNOTs only, stating in Section 5 that 'We measure the compilation time based on the number of CNOTs and the quantum execution time based on the quantum circuit depth' and that 'No actual quantum execution was performed during the tests; only the decomposition was evaluated.' This is an unvalidated modeling choice at the load-bearing center of the paper: Table 2's two profiles are named after real time costs, yet no evidence is given that CNOT count is proportional to compiler runtime (which includes graph manipulation, mapping, and scheduling passes) or that CNOT-only depth determines execution time on hardware (which depends on routing, gate errors, connectivity, and auxiliary-qubit allocation/reset costs). The authors themselves concede in Section 7 that 'circuit mapping may have a significant impact on the final performance.' Without validation of these proxies, the first-place ranking of Network decomposition in both profiles is not justified; at minimum, the profiles should be re-labeled as CNOT-count-minimizing and depth-minimizing, or supplemented with wall-clock compilation measurements and mapped-circuit execution estimates.
  2. [Section 6 (Results Analysis) and Table 2] The rankings in Table 2 are presented as absolute, but the underlying curves in Figures 9–11 cross as a function of n. The text itself states in Section 6 that logarithmic-depth algorithms 'demonstrate their advantages only in scenarios involving more than 1000 qubits.' Because the table gives no qubit-count range, a compiler developer could apply the 'Execution Time' profile to small circuits where a linear-depth algorithm with fewer CNOTs may actually execute faster. The profiles need to specify the n-range for which each ranking is intended, or provide the lookup table mentioned in Section 7 as a concrete artifact rather than a future possibility.
  3. [Section 5 and Table 1 (caption)] The sentence 'The quantum circuit depth and the number of CNOTs presented in Table 1 were obtained by fitting the curves of the benchmark data' is the only description of the fitting procedure. The paper does not report the qubit-count samples, the number of data points, the fit function class (e.g., linear regression through the origin), or goodness-of-fit measures. Since Table 1 presents exact-looking constants (e.g., 4n, 6n, n^2/10), the uncertainty in these fitted values is unclear; this matters for the ordering in Table 2 if two algorithms' curves are close. The methodology should be fully described for reproducibility.
minor comments (5)
  1. [Table 1] The entry 'Liner Depth' in the Phase and Hadamard section appears to be a typo for 'Linear Depth'.
  2. [Table 1 and Figure 9] The Pauli Gates section of Table 1 omits the Linear Depth row, although Figure 9 and Table 2 include it; since Linear Depth is described in Section 4.1 as the fallback for any gate, the table should list it under Pauli Gates for completeness.
  3. [Figures 9 and 10] The horizontal-axis labels appear to be rendered incorrectly (e.g., 'Number of bits' instead of 'Number of qubits'); please check the figure source files.
  4. [Section 4.1] The sentence 'Figure 3 illustrates two variants of the algorithm for a 8-controlled Pauli X gate' should read 'an 8-controlled Pauli X gate.'
  5. [Abstract and Section 1] The claim that this is 'the first study to both implement and analyze the current state-of-the-art decomposition methods within a single platform' is a strong novelty assertion; the authors should either soften it or provide a reference to demonstrate that no prior unified implementation exists.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the profiles are direct rankings of measured benchmark data; self-citations are benchmarked objects, not load-bearing assumptions.

full rationale

The paper's central deliverable, Table 2's two compilation profiles, is a direct ranking of measured benchmark quantities—CNOT count and CNOT-only circuit depth—produced by the implemented decomposition algorithms. Section 5 states: 'We measure the compilation time based on the number of CNOTs and the quantum execution time based on the quantum circuit depth... No actual quantum execution was performed during the tests; only the decomposition was evaluated.' The profiles are read off the data in Figures 9-11, not derived from a model fitted to that same data. Table 1's asymptotic formulas are explicitly descriptive ('The quantum circuit depth and the number of CNOTs presented in Table 1 were obtained by fitting the curves of the benchmark data'), and Table 2 is said to be 'based on the data presented in the previous section,' so no fitted quantity is relabeled as a prediction. The self-citations (Rosa et al. [22,23]) supply an algorithm (SU(2) Rewrite) and a compiler feature (automatic auxiliary-qubit allocation) that are benchmarked as objects under test rather than invoked as proof of the ranking; they are published external results with independent content. The unvalidated proxy choice (CNOT count for compilation time, CNOT-only depth for execution time) and the paper's own caveat that 'circuit mapping may have a significant impact on the final performance' are validity and correctness concerns, not circularity: the conclusion is not equivalent to its inputs by construction. No circular step can be exhibited.

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

The central claim rests on the two listed assumptions: faithful implementation of known algorithms and the validity of the two proxy metrics. No new entities are introduced. The fitted constants in Table 1 are present but do not drive the recommended profiles.

free parameters (1)
  • Fitted complexity constants for Table 1 = Not reported
    The depth and CNOT counts in Table 1 are reported as fitted curves of benchmark data, implying free constant and exponent parameters. These do not affect the central profiles in Table 2, but they are introduced to summarize the data and are not given with fit quality.
assumptions (2)
  • domain assumption The implemented algorithms are faithful to the referenced papers.
    The benchmark ranks depend entirely on the correctness of the code written for each algorithm. A buggy or suboptimal reimplementation would change the ordering. The paper does not provide independent verification of each implementation.
  • domain assumption CNOT count is a valid proxy for compilation time, and CNOT-only circuit depth is a valid proxy for quantum execution time.
    Section 5 states that the number of CNOTs allows inference of the impact on subsequent compilation steps, and depth represents minimum execution time. This is a modeling choice that is not empirically validated against actual timings.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Quantum Gate Decomposition: A Study of Compilation Time vs. Execution Time Trade-offs." pith.science (2026). https://pith.science/paper/WXWFFBD3

@misc{pith2026250420291,
  author       = {Pith},
  title        = {Pith review of: Quantum Gate Decomposition: A Study of Compilation Time vs. Execution Time Trade-offs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WXWFFBD3}},
  note         = {Machine review of arXiv:2504.20291}
}
read the original abstract

Similar to classical programming, high-level quantum programming languages generate code that cannot be executed directly by quantum hardware and must be compiled. However, unlike classical code, quantum programs must be compiled before each execution, making the trade-off between compilation time and execution time particularly significant. In this paper, we address the first step of quantum compilation: multi-qubit gate decomposition. We analyze the trade-offs of state-of-the-art decomposition algorithms by implementing them in the Ket quantum programming platform and collecting numerical performance data. This is the first study to both implement and analyze the current state-of-the-art decomposition methods within a single platform. Based on our findings, we propose two compilation profiles: one optimized for minimizing compilation time and another for minimizing quantum execution time. Our results provide valuable insights for both quantum compiler developers and quantum programmers, helping them make informed decisions about gate decomposition strategies and their impact on overall performance.

Figures

Figures reproduced from arXiv: 2504.20291 by the authors.

Figure 1
Figure 1. Grover diffusion operation implemented using [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Arbitrary quantum state preparation algorithm [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Network decomposition for 8-controlled Pauli X. def myY(q): with around(SD, q): X(q) def myZ(q): with around(H, q): X(q) def myCY(c, t): ctrl(c, myY)(t) def myCZ(c, t): ctrl(c, myZ)(t) (a) Ket code. c t /2 P /2 P (b) myCY Circuit. c t H H (c) myCZ Circuit [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (6 more)
Figure 5
Figure 5. Figure 5: V Chain decomposition for 6-controlled Pauli [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]
Figure 6
Figure 6. Figure 6: Single Aux decomposition for 8-controlled Pauli [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]
Figure 8
Figure 8. Figure 8: Decomposition for a 3-controlled Hadamard [PITH_FULL_IMAGE:figures/full_fig_p005_8.png]
Figure 9
Figure 9. Figure 9: Comparison of various decomposition algorithms [PITH_FULL_IMAGE:figures/full_fig_p006_9.png]
Figure 10
Figure 10. Figure 10: Comparison of various decomposition algorithms [PITH_FULL_IMAGE:figures/full_fig_p007_10.png]
Figure 11
Figure 11. Figure 11: Comparison across different decomposition al [PITH_FULL_IMAGE:figures/full_fig_p007_11.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

35 extracted references · 6 canonical work pages

  1. [1]

    Scott Aaronson and Daniel Gottesman. 2004. Improved Simulation of Stabilizer Circuits.Physical Review A70, 5 (Nov. 2004), 052328. doi:10.1103/PhysRevA.70. 052328

    doi:10.1103/physreva.70 2004

  2. [2]

    Thomas Alexander, Naoki Kanazawa, Daniel J Egger, Lauren Capelluto, Christo- pher J Wood, Ali Javadi-Abhari, and David C McKay. 2020. Qiskit Pulse: Program- ming Quantum Computers through the Cloud with Pulses.Quantum Science and Technology5, 4 (Aug. 2020), 044006. doi:10.1088/2058-9565/aba404

    doi:10.1088/2058-9565/aba404 2020

  3. [3]

    Bennett, Richard Cleve, David P

    Adriano Barenco, Charles H. Bennett, Richard Cleve, David P. DiVincenzo, Nor- man Margolus, Peter Shor, Tycho Sleator, John A. Smolin, and Harald Weinfurter

    work page

  4. [4]

    Sohini Chowdhury, Rupali Gill, Arti Badhoutiya, Arun Pratap Srivastava, Akhilesh Kumar Khan, and Rajesh Singh. 2024. Qubit Allocation Strategies in Quantum Computing for Improved Computational Efficiency. In2024 4th International Conference on Innovative Practices in Technology and Management (ICIPTM). IEEE, Noida, India, 1–6. doi:10.1109/ICIPTM59628.2024...

    arXiv 2024

  5. [5]

    Baptiste Claudon, Julien Zylberman, César Feniou, Fabrice Debbasch, Alberto Peruzzo, and Jean-Philip Piquemal. 2024. Polylogarithmic-Depth Controlled-NOT Gates without Ancilla Qubits.Nature Communications15, 1 (July 2024), 5886. doi:10.1038/s41467-024-50065-x

    doi:10.1038/s41467-024-50065-x 2024

  6. [6]

    Bob Coecke and Ross Duncan. 2011. Interacting Quantum Observables: Cate- gorical Algebra and Diagrammatics.New Journal of Physics13, 4 (April 2011), 043016. doi:10.1088/1367-2630/13/4/043016

    doi:10.1088/1367-2630/13/4/043016 2011

  7. [7]

    Evandro Chagas Ribeiro Da Rosa and Rafael De Santiago. 2022. Ket Quantum Programming.ACM Journal on Emerging Technologies in Computing Systems18, 1 (Jan. 2022), 1–25. doi:10.1145/3474224

    doi:10.1145/3474224 2022

  8. [8]

    Da Silva and Daniel K

    Adenilton J. Da Silva and Daniel K. Park. 2022. Linear-Depth Quantum Circuits for Multiqubit Controlled Gates.Physical Review A106, 4 (Oct. 2022), 042602. doi:10.1103/PhysRevA.106.042602

    doi:10.1103/physreva.106.042602 2022

Show all 35 references
  1. [9]

    Simon J Devitt, William J Munro, and Kae Nemoto. 2013. Quantum Error Cor- rection for Beginners.Reports on Progress in Physics76, 7 (July 2013), 076001. doi:10.1088/0034-4885/76/7/076001

    2013 doi

  2. [10]

    Craig Gidney and Martin Ekerå. 2021. How to Factor 2048 Bit RSA Integers in 8 Hours Using 20 Million Noisy Qubits.Quantum5 (April 2021), 433. doi:10.22331/ q-2021-04-15-433

  3. [11]

    Abanin, Laleh Aghababaie-Beni, Igor Aleiner, Trond I

    Google Quantum AI and Collaborators, Rajeev Acharya, Dmitry A. Abanin, Laleh Aghababaie-Beni, Igor Aleiner, Trond I. Andersen, Markus Ansmann, Frank Arute, Kunal Arya, Abraham Asfaw, Nikita Astrakhantsev, Juan Atalaya, Ryan Babbush, Dave Bacon, Brian Ballard, Joseph C. Bardin,...

    2025

  4. [12]

    Lov K. Grover. 1996. A Fast Quantum Mechanical Algorithm for Database Search. InProceedings of the Twenty-Eighth Annual ACM Symposium on Theory of Computing - STOC ’96. ACM Press, Philadelphia, Pennsylvania, United States, 212–219. doi:10.1145/237814.237866

    1996

  5. [13]

    You Huang, Mohammad T Amawi, Francesco Poggiali, Fazhan Shi, Jiangfeng Du, and Friedemann Reinhard. 2023. Calibrating Single-Qubit Gates by a Two- Dimensional Rabi Oscillation.AIP Advances13, 3 (March 2023), 035226. doi:10. 1063/5.0139454

    2023

  6. [14]

    Raban Iten, Roger Colbeck, Ivan Kukuljan, Jonathan Home, and Matthias Chris- tandl. 2016. Quantum Circuits for Isometries.Physical Review A93, 3 (March 2016), 032318. doi:10.1103/PhysRevA.93.032318

    2016 doi

  7. [15]

    Raban Iten, Oliver Reardon-Smith, Emanuel Malvetti, Luca Mondada, Gabrielle Pauvert, Ethan Redmond, Ravjot Singh Kohli, and Roger Colbeck. 2021. Intro- duction to UniversalQCompiler. arXiv:1904.01072 [quant-ph] doi:10.48550/arXiv. 1904.01072

    2021 doi arXiv

  8. [16]

    Gushu Li, Yufei Ding, and Yuan Xie. 2019. Tackling the Qubit Mapping Problem for NISQ-Era Quantum Devices. InProceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems. ACM, Providence RI USA, 1001–1014. d...

    2019

  9. [17]

    Dmitri Maslov. 2016. Advantages of Using Relative-Phase Toffoli Gates with an Application to Multiple Control Toffoli Optimization.Physical Review A93, 2 (Feb. 2016), 022311. doi:10.1103/PhysRevA.93.022311

    2016 doi

  10. [18]

    McKay, Christopher J

    David C. McKay, Christopher J. Wood, Sarah Sheldon, Jerry M. Chow, and Jay M. Gambetta. 2017. Efficient Z Gates for Quantum Computing.Physical Review A 96, 2 (Aug. 2017), 022330. doi:10.1103/PhysRevA.96.022330

    2017 doi

  11. [19]

    Nielsen and Isaac L

    Michael A. Nielsen and Isaac L. Chuang. 2010.Quantum Computation and Quantum Information(10th anniversary edition ed.). Cambridge university press, Cambridge. doi:10.1017/CBO9780511976667

    2010 doi

  12. [20]

    Siyuan Niu, Adrien Suau, Gabriel Staffelbach, and Aida Todri-Sanial. 2020. A Hardware-Aware Heuristic for the Qubit Mapping Problem in the NISQ Era. IEEE Transactions on Quantum Engineering1 (2020), 1–14. doi:10.1109/TQE.2020. 3026544

    2020 doi

  13. [21]

    Gambetta, and Kristan Temme

    Christophe Piveteau, David Sutter, Sergey Bravyi, Jay M. Gambetta, and Kristan Temme. 2021. Error Mitigation for Universal Gates on Encoded Qubits.Physical Review Letters127, 20 (Nov. 2021), 200505. doi:10.1103/PhysRevLett.127.200505

    2021 doi

  14. [22]

    Evandro C. R. Rosa, Eduardo I. Duzzioni, and Rafael De Santiago. 2025. Optimizing Gate Decomposition for High-Level Quantum Programming.Quantum9 (March 2025), 1659. doi:10.22331/q-2025-03-12-1659

    2025 doi

  15. [23]

    Evandro C. R. Rosa, Jerusa Marchi, Eduardo I. Duzzioni, and Rafael de Santiago

  16. [24]

    Peter W. Shor. 1997. Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer.SIAM J. Comput.26, 5 (Oct. 1997), 1484–1509. doi:10.1137/S0097539795293172

    1997 doi

  17. [25]

    Schuster

    Leandro Stefanazzi, Kenneth Treptow, Neal Wilcer, Chris Stoughton, Collin Bradford, Sho Uemura, Silvia Zorzetti, Salvatore Montella, Gustavo Cancelo, Sara Sussman, Andrew Houck, Shefali Saxena, Horacio Arnaldi, Ankur Agrawal, Helin Zhang, Chunyang Ding, and David I. Schuster. ...

    2022 doi

  18. [26]

    Krysta Svore, Alan Geller, Matthias Troyer, John Azariah, Christopher Granade, Bettina Heim, Vadym Kliuchnikov, Mariia Mykhailova, Andres Paz, and Martin Roetteler. 2018. Q#: Enabling Scalable Quantum Computing and Development with a High-level DSL. InProceedings of the Real W...

    2018

  19. [27]

    Azevedo, Ismael C

    Rafaella Vale, Thiago Melo D. Azevedo, Ismael C. S. Araújo, Israel F. Araujo, and Adenilton J. Da Silva. 2024. Circuit Decomposition of Multicontrolled Special Unitary Single-Qubit Gates.IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems43, 3 (March ...

    2024

  20. [28]

    Robert Wille and Lukas Burgholzer. 2023. MQT QMAP: Efficient Quantum Circuit Mapping. InProceedings of the 2023 International Symposium on Physical Design. ACM, Virtual Event USA, 198–204. doi:10.1145/3569052.3578928

    2023

  21. [29]

    W. K. Wootters and W. H. Zurek. 1982. A Single Quantum Cannot Be Cloned. Nature299, 5886 (Oct. 1982), 802–803. doi:10.1038/299802a0

    1982 doi

  22. [30]

    Pengcheng Zhu, Weiping Ding, Lihua Wei, Xueyun Cheng, Zhijin Guan, and Shiguang Feng. 2023. A Variation-Aware Quantum Circuit Mapping Approach Based on Multi-Agent Cooperation.IEEE Trans. Comput.72, 8 (Aug. 2023), 2237–

    2023

  23. [31]

    Pengcheng Zhu, Zhijin Guan, and Xueyun Cheng. 2020. A Dynamic Look-Ahead Heuristic for the Qubit Mapping Problem of NISQ Computers.IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems39, 12 (Dec. 2020), 4721–4735. doi:10.1109/TCAD.2020.2970594

    2020

  24. [32]

    Ben Zindorf and Sougato Bose. 2024. Efficient Implementation of Multi- Controlled Quantum Gates. arXiv:2404.02279 [quant-ph] doi:10.48550/arXiv. 2404.02279

    2024 doi arXiv

  25. [1995]

    1995), 3457–3467

    Elementary Gates for Quantum Computation.Physical Review A52, 5 (Nov. 1995), 3457–3467. doi:10.1103/PhysRevA.52.3457

    1995 doi

  26. [2024]

    arXiv:2412.20543 [quant-ph] doi:10.48550/arXiv.2412.20543

    Automated Auxiliary Qubit Allocation in High-Level Quantum Program- ming. arXiv:2412.20543 [quant-ph] doi:10.48550/arXiv.2412.20543

    doi arXiv

  27. [2249]

    doi:10.1109/TC.2023.3242208

    2023

Pith tools

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