Pith. sign in

REVIEW 3 major objections 5 minor 60 references

POPQC: Parallel Optimization for Quantum Circuits (Extended Version)

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

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

Pith's one-line read The paper introduces POPQC, a parallel algorithm that provably optimizes quantum circuits to local optimality in near-linear work and logarithmic span, and demonstrates orders-of-magnitude speedups over sequential optimizers.

desk verdict A genuinely useful parallel circuit optimizer with the right complexity bounds, but the local-optimality guarantee is conditional on a strong oracle property the paper never verifies. read the letter →

arxiv 2506.13720 v1 pith:6ZF6JDZW submitted 2025-06-16 cs.DC quant-ph

Pengyu Liu , Jatin Arora , Mingkuan Xu , Umut A. Acar This is my paper · ORCID
classification cs.DCquant-ph MSC 68W1068Q12
keywords quantumcircuitoptimizationparallelalgorithmslocaloptimalitywork-spananalysisoracleoptimizerindextreefingerschedulingcomputing
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 claims that quantum circuit optimization, previously a sequential and superlinear affair, can be made parallel without sacrificing quality. It presents POPQC, an algorithm that maintains "fingers" into the circuit, optimizes non-interfering segments concurrently in rounds, and provably terminates with a locally optimal circuit. For constant segment size $\Omega$, the algorithm requires O(n log n) work and O(r log n) span, with at most O(n) calls to an external oracle optimizer. The practical significance is that large circuits that stymie existing optimizers for 24 hours or more can be optimized in seconds on a 64-core machine, with essentially the same gate reduction. A sympathetic reader would care because this is a provably efficient parallel approach to a task central to near-term quantum computing.

What carries the argument

The central mechanism is the finger set indexed into a sparse circuit representation. A finger is an index in the gate array near which the algorithm presumes optimization is needed; two fingers are non-interfering if at least 2 $\Omega$ gates separate them, so their segments can be optimized in parallel. The circuit is stored as a gate array with tombstones plus a balanced index tree whose leaves are weighted 1 for a live gate and 0 for a tombstone; the tree answers "how many live gates before position i" and "what is the i-th live gate" in logarithmic work, letting the algorithm locate segments and apply updates without rescanning. The paper defines a well-behaved oracle as one whose optimized output has every subsegment already optimal, which is the property enabling the finger invariant to survive round after round.

What would settle it

Take a 2 $\Omega$-segment from a benchmark circuit, optimize it with VOQC, then cut a subsegment from the middle of the output and run VOQC on it; if that subsegment shrinks, the oracle is not well-behaved and POPQC's local-optimality guarantee does not apply.

Watch

Extended reading notes

Core claim

The central discovery is that local optimality - the property that every $\Omega$-gate segment of the circuit is optimal with respect to a given oracle - can be attained by a parallel, work-efficient algorithm. Instead of the sequential cut-optimize-meld-compress scheme of prior work, the algorithm keeps a set of finger indices, selects a constant fraction of non-interfering fingers per round, optimizes the 2-$\Omega$ segments around them in parallel, and updates fingers only at segment boundaries where the oracle made changes. The invariant that every unoptimized $\Omega$-segment contains a finger is preserved across rounds; when no fingers remain, every $\Omega$-segment has been checked by the oracle, yielding local optimality. The proof of efficiency rests on a potential function showing O(n) total oracle calls, a finger-count bound of O($\Omega$ n), and an index-tree data structure for the circuit that supports each access and update in O(log n) work.

Load-bearing premise

The local-optimality guarantee collapses if the oracle optimizer is not "well-behaved" - meaning that after it optimizes a segment, some subsegment of that output could still be improved by the oracle itself.

Editorial extensions

If this is right

  • For any circuit of n gates and constant Omega, POPQC terminates in O(n log n) total work and O(r log n) span, making near-linear-time optimization achievable in principle.
  • The output circuit is locally optimal: no Omega-segment can be further improved by the oracle, a formal quality guarantee stronger than heuristic single-pass optimization.
  • The algorithm makes only O(n) oracle calls, so the cost is dominated by the oracle work; in practice, over 90% of the time is spent inside the oracle.
  • A single-processor run of POPQC already outperforms the best sequential local optimizer, and with 64 threads it beats the VOQC baseline by orders of magnitude, with gate-reduction quality within about half a percent.
  • The same algorithm works with different oracles and cost functions; using Quartz with a depth-aware cost, it reduces circuit depth by up to 20% even when gate-count-only optimization finds nothing.

Reading between the lines

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

  • If the well-behaved property can be verified or enforced for a given oracle, POPQC's local-optimality guarantee becomes a compositional certificate: each segment's optimality is independent, so the output can be checked segment-by-segment in parallel, a natural testable quality metric for large circuits.
  • The index-tree representation may be reusable beyond this algorithm, for example as a runtime scheduler for streaming circuit transformations or for coarse-grained parallel compilation passes that must maintain a compact view of a sparse gate list.
  • The finger-invariant idea generalizes: any optimization task with a local, checkable optimality notion and a well-behaved local repair routine could be parallelized in the same rounds-of-parallel-repair pattern, not just quantum circuit optimization.
  • The observed small number of rounds suggests that real quantum circuits have limited long-range interaction under this optimizer; if that locality is structural, then the empirical round count could be formalized for natural circuit classes, dropping the r factor from the span bound.
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 introduces POPQC, a parallel algorithm for local optimization of quantum circuits. The algorithm maintains a set of 'fingers' marking potentially unoptimized Ω-segments, and in each round it selects non-interfering fingers and optimizes the surrounding 2Ω-segments in parallel using an external oracle optimizer. The circuit is stored in a sparse array with an index tree that supports logarithmic-time queries for live gates. The authors prove work O(n(Ω lg n + W)) and span O(r(lg n + S)), where r is the number of rounds, and claim that the returned circuit is locally optimal, meaning every Ω-segment is optimal with respect to the oracle. They implement the algorithm in Rust using VOQC and Quartz as oracles and report large speedups over sequential baselines on a 64-core machine, with code available on GitHub.

Significance. If the central claims hold, POPQC is a significant contribution: it is, to my knowledge, the first parallel quantum circuit optimizer with provable near-linear work and a formal (if weak) quality guarantee, backed by a large and thoughtfully designed experimental evaluation. The potential-function argument for bounding the number of oracle calls is clean, and the index-tree data structure is a useful ingredient beyond this specific application. The paper ships its code and evaluates against multiple optimizers and benchmark families, which strengthens confidence in the practical claims. However, the local-optimality theorem rests on an unstated and unverified 'well-behaved oracle' assumption, and the pseudocode contains inconsistencies between the described 2Ω-segments and the actual indices used; these issues directly affect the paper's central correctness claim and must be resolved before the guarantee can be accepted.

major comments (3)
  1. [Section 6 (well-behaved oracle; Theorem 7)] The local-optimality guarantee is not established for the implemented system. Lemma 6 and Theorem 7 rely on the assumption that the oracle is 'well-behaved' (Section 6, before Lemma 6): for any A' = oracle(A), every segment of A' must already be optimal with respect to the oracle. The paper gives no proof that VOQC or Quartz, the two oracles used in Section 7, have this property, and Section 7.4 itself reports that POPQC finds optimizations that a single VOQC run misses, which is exactly the kind of behavior the well-behaved property rules out. Since the abstract states the optimality guarantee unconditionally, the authors should either verify the property (for instance, by exhaustively checking oracle outputs on all segments for the benchmark circuits), or explicitly state and empirically test the assumption as part of Theorem 7 and adjust the abstract accordingly.
  2. [Algorithm 3, line 4] The pseudocode optimizes a segment of 2Ω+1 gates, not 2Ω gates: the index range i ∈ [-Ω, Ω] contains 2Ω+1 values. The surrounding text, Lemma 6, Theorem 4, and Figure 2 all describe 2Ω-segments. This off-by-one changes the size of the segment submitted to the oracle and affects the non-interference condition, the oracle work bound W, and the invariant argument in Lemma 6. Please make the pseudocode and the prose consistent (for example, use i ∈ [-Ω, Ω-1]) and adjust the analysis if the intended segment is indeed 2Ω+1 gates.
  3. [Algorithms 2–4, finger representation] The definition of a finger is inconsistent between the initial state and subsequent rounds. Algorithm 2 initializes F with array indices (0, Ω, 2Ω, ...), while Algorithm 3 line 7 adds new fingers at Circuit.before(C, f) − Ω and Circuit.before(C, f) + Ω, which are gate-count positions rather than array indices. In the next round, Algorithm 4 line 3 calls Circuit.before(C, F[i]) on those values, but Circuit.before is defined only for an array index (Section 3). No mapping from gate-count positions back to array indices is provided, so the pseudocode as written is not a well-defined algorithm and the proofs, which treat all fingers uniformly, do not cover the described code.
minor comments (5)
  1. [Algorithm 4, line 2] The parmap iterates over i ∈ {0, ..., |F|}, which includes i = |F| and accesses F[|F|] out of bounds; the upper limit should be |F|−1.
  2. [Algorithm 3, line 8] The function padWithTombstone is used but never defined; its semantics should be described, including how the optimized segment is mapped back onto the original 2Ω positions.
  3. [Section 2.3 and Introduction] The introduction attributes QMA-hardness of global circuit optimization to reference [38], but [38] is the Nam et al. optimizer paper; the background section correctly cites [25] (Janzing et al.) for this fact, so the citation in Section 1 appears to be wrong.
  4. [Figure 1] The figure uses the label 'CNOT1,2' without defining the gate-index convention, which makes the example hard to follow.
  5. [Abstract and Appendix A.3] The abstract says 'a Ω-deep circuit' where 'an Ω-segment' is intended, and Appendix A.3 contains a typo, 'accroding' for 'according'.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: complexity and local-optimality proofs are derived from explicit oracle assumptions; self-citations are background/baseline only.

full rationale

The derivation chain is self-contained. Theorem 4's work/span bounds are proven from explicit assumptions about oracle work W and span S (Section 5), and the O(n) oracle-call bound follows from a potential-function argument (Lemma 2) that does not fit any parameter to the output. Theorem 7's local-optimality guarantee is conditional on the explicitly stated well-behaved-oracle assumption (Section 6, before Lemma 6); that assumption is a hypothesis about the oracle, not a conclusion obtained by fitting or by renaming the target result. The finger invariant is proved in Lemmas 5-6, and the termination/correctness argument in Theorem 7 is carried out in the paper rather than imported. The self-citations (e.g., [8] for the local-optimality framework and OAC baseline, [59] for Quartz) are used for motivation, baselines, and evaluation, and no proof step reduces to an unverified self-citation. The skeptic's concern that VOQC/Quartz may fail the well-behaved property is a soundness/empirical limitation of the implemented system, not a circularity in the mathematical derivation. Therefore no circular step can be quoted, and the score is 0.

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

The central algorithm rests on two substantive assumptions: a well-behaved oracle and the index-tree cost model. The only hand-chosen numeric knob is Omega. No new physical or formal entities are postulated.

free parameters (1)
  • Omega (segment size) = 200 (default; 400 for OAC comparison; 100 for Quartz)
    Hand-chosen in experiments to balance speed and quality. The theoretical claims do not depend on a particular value, but the practical speedup and quality numbers do. Sensitivity is shown in Appendix A.3.
assumptions (4)
  • domain assumption The oracle is well-behaved: after optimizing a segment, every subsegment of the output is locally optimal with respect to the oracle.
    Introduced in Section 6 and required by Lemma 6 and Theorem 7. Not verified for VOQC or Quartz. If violated, POPQC's local-optimality guarantee can fail.
  • domain assumption The oracle returns an equivalent circuit never larger than its input for the cost metric being optimized.
    The algorithm accepts an oracle result only when |optSegment| < |segment|, so this is built into the update rule; the complexity analysis assumes oracle reductions shrink global circuit size by at least one gate.
  • standard math Parallel map adds logarithmic span and can process independent segments without conflicts.
    Standard work-span model assumption (Section 2.4); non-interfering fingers ensure disjoint segments.
  • domain assumption Index tree supports before/get/substitute/gates with stated logarithmic costs on a sparse array with tombstones.
    Section 3 describes the data structure; these cost bounds are standard for a weighted binary tree but are assumed rather than formally proved in the paper.

how reviews work

0 comments
Cite this review

Pith. "Pith review of POPQC: Parallel Optimization for Quantum Circuits (Extended Version)." pith.science (2026). https://pith.science/paper/6ZF6JDZW

@misc{pith2026250613720,
  author       = {Pith},
  title        = {Pith review of: POPQC: Parallel Optimization for Quantum Circuits (Extended Version)},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/6ZF6JDZW}},
  note         = {Machine review of arXiv:2506.13720}
}
abstract

Optimization of quantum programs or circuits is a fundamental problem in quantum computing and remains a major challenge. State-of-the-art quantum circuit optimizers rely on heuristics and typically require superlinear, and even exponential, time. Recent work proposed a new approach that pursues a weaker form of optimality called local optimality. Parameterized by a natural number $\Omega$, local optimality insists that each and every $\Omega$-segment of the circuit is optimal with respect to an external optimizer, called the oracle. Local optimization can be performed using only a linear number of calls to the oracle but still incurs quadratic computational overheads in addition to oracle calls. Perhaps most importantly, the algorithm is sequential. In this paper, we present a parallel algorithm for local optimization of quantum circuits. To ensure efficiency, the algorithm operates by keeping a set of fingers into the circuit and maintains the invariant that a $\Omega$-deep circuit needs to be optimized only if it contains a finger. Operating in rounds, the algorithm selects a set of fingers, optimizes in parallel the segments containing the fingers, and updates the finger set to ensure the invariant. For constant $\Omega$, we prove that the algorithm requires $O(n\lg{n})$ work and $O(r\lg{n})$ span, where $n$ is the circuit size and $r$ is the number of rounds. We prove that the optimized circuit returned by the algorithm is locally optimal in the sense that any $\Omega$-segment of the circuit is optimal with respect to the oracle.

Figures

Figures reproduced from arXiv: 2506.13720 by the authors.

Figure 1
Figure 1. The index tree data structure. a) A circuit with [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. An illustration of a run of the POPQC algorithm. We assume Ω = 2, and thus the segments being optimized consist of 2Ω = 4 gates. Therefore, 𝐿 decreases by at least 1 for each oracle call in either case. Initially, we have 𝐿 =  𝑛 Ω  + 2𝑛. Hence, the number of oracle calls is 𝑂(𝑛). □ We have the following lemma by combining the two lemmas above. Lemma 3 (Number of Fingers). Let F 𝑖 be the set of fingers in the 𝑖-th … view at source ↗
Figure 3
Figure 3. Self-speedup using different numbers of threads [PITH_FULL_IMAGE:figures/full_fig_p011_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Number of rounds for different benchmarks. For [PITH_FULL_IMAGE:figures/full_fig_p011_4.png]
Figure 5
Figure 5. Figure 5: Self-speedup with respect to the number of gates [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]
Figure 6
Figure 6. Figure 6: Gate and depth reduction using Quartz with differ￾ent cost functions. Each bar corresponds to the average of the four instances in each circuit family. small circuits, algorithms for generating asymptotically optimal T count circuits[18] exist but are not efficient for…
Figure 7
Figure 7. Figure 7: (Left) Work, measured by running time, vs. number of gates for different benchmarks. (Right) Number of oracle calls [PITH_FULL_IMAGE:figures/full_fig_p016_7.png]
Figure 8
Figure 8. Figure 8: Percentage of oracle execution time across different benchmarks. Within each benchmark, bars are arranged from [PITH_FULL_IMAGE:figures/full_fig_p017_8.png]
Figure 9
Figure 9. Figure 9: Impact of Ω on the performance of POPQC. Average across all benchmarks. The star indicates the default value of Ω = 200, which is used in all experiments unless explicitly stated otherwise. Benchmark Left-justified Right-justified Default Order BoolSat 83.52% 83.52% 83…

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

60 extracted references · 41 canonical work pages

  1. [1]

    Acar and Guy E

    Umut A. Acar and Guy E. Blelloch. Algorithms: Parallel and Sequential . 2022. http:www.algorithms-book.com

    work page 2022

  2. [2]

    Acar, Arthur Charguéraud, Adrien Guatto, Mike Rainey, and Filip Sieczkowski

    Umut A. Acar, Arthur Charguéraud, Adrien Guatto, Mike Rainey, and Filip Sieczkowski. Heartbeat scheduling: Provable efficiency for nested parallelism. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2018, pages 769–782, 2018. SPAA ’25, July 28–August 1, 2025, Portland, OR, USA Pengyu Liu, Jatin Aro...

    work page 2018

  3. [3]

    Acar, Arthur Charguéraud, and Mike Rainey

    Umut A. Acar, Arthur Charguéraud, and Mike Rainey. Oracle scheduling: Con- trolling granularity in implicitly parallel languages. In ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 499–518, 2011

    work page 2011

  4. [4]

    Formal methods in quantum circuit design

    Matthew Amy. Formal methods in quantum circuit design. 2019

    work page 2019

  5. [5]

    Polynomial-time t-depth optimization of clifford+ t circuits via matroid partitioning

    Matthew Amy, Dmitri Maslov, and Michele Mosca. Polynomial-time t-depth optimization of clifford+ t circuits via matroid partitioning. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems , 33(10):1476–1489, 2014

    work page 2014

  6. [6]

    Jatin Arora, Sam Westrick, and Umut A. Acar. Provably space efficient parallel functional programming. In Proceedings of the 48th Annual ACM Symposium on Principles of Programming Languages (POPL) , 2021

    work page 2021

  7. [7]

    Jatin Arora, Sam Westrick, and Umut A. Acar. Efficient parallel functional programming with effects. Proc. ACM Program. Lang., 7(PLDI):1558–1583, 2023

    work page 2023

  8. [8]

    Local Optimization of Quantum Circuits (Extended Version)

    Jatin Arora, Mingkuan Xu, Sam Westrick, Pengyu Liu, Dantong Li, Yongshan Ding, and Umut A Acar. Local optimization of quantum circuits (extended version). arXiv preprint arXiv:2502.19526, 2025

    work page Pith review arXiv 2025

Show all 60 references
  1. [9]

    Post synthesis-optimization of reversible circuit using template matching

    Chandan Bandyopadhyay, Robert Wille, Rolf Drechsler, and Hafizur Rahaman. Post synthesis-optimization of reversible circuit using template matching. In 2020 24th International Symposium on VLSI Design and Test (VDAT) , pages 1–4. IEEE, 2020

    2020

  2. [10]

    The computer as a physical system: A microscopic quantum me- chanical hamiltonian model of computers as represented by turing machines

    Paul Benioff. The computer as a physical system: A microscopic quantum me- chanical hamiltonian model of computers as represented by turing machines. Journal of Statistical Physics , 22:563–591, 05 1980

    1980

  3. [11]

    Pennylane: Automatic differentiation of hybrid quantum-classical computations

    Ville Bergholm, Josh Izaac, Maria Schuld, Christian Gogolin, Shahnawaz Ahmed, Vishnu Ajith, M Sohaib Alam, Guillermo Alonso-Linaje, B AkashNarayanan, Ali Asadi, et al. Pennylane: Automatic differentiation of hybrid quantum-classical computations. arXiv preprint arXiv:1811.04968, 2018

    2018 arXiv

  4. [12]

    Quantum machine learning

    Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, and Seth Lloyd. Quantum machine learning. Nature, 549(7671):195–202, 2017

    2017

  5. [13]

    Quantum algorithm for systems of linear equations with exponentially improved dependence on precision

    Andrew M Childs, Robin Kothari, and Rolando D Somma. Quantum algorithm for systems of linear equations with exponentially improved dependence on precision. SIAM Journal on Computing , 46(6):1920–1950, 2017

    1920

  6. [14]

    Towards optimal topology aware quantum circuit synthesis

    Marc G Davis, Ethan Smith, Ana Tudor, Koushik Sen, Irfan Siddiqi, and Costin Iancu. Towards optimal topology aware quantum circuit synthesis. In 2020 IEEE International Conference on Quantum Computing and Engineering (QCE) , pages 223–234. IEEE, 2020

    2020

  7. [15]

    Quantum phases of matter on a 256-atom programmable quantum simulator

    Sepehr Ebadi, Tout T Wang, Harry Levine, Alexander Keesling, Giulia Semeghini, Ahmed Omran, Dolev Bluvstein, Rhine Samajdar, Hannes Pichler, Wen Wei Ho, et al. Quantum phases of matter on a 256-atom programmable quantum simulator. Nature, 595(7866):227–232, 2021

    2021

  8. [16]

    Simulating physics with computers

    Richard P Feynman. Simulating physics with computers. In Feynman and computation, pages 133–153. CRC Press, 2018

    2018

  9. [17]

    Quan- tum circuit optimization with deep reinforcement learning

    Thomas Fösel, Murphy Yuezhen Niu, Florian Marquardt, and Li Li. Quan- tum circuit optimization with deep reinforcement learning. arXiv preprint arXiv:2103.07585, 2021

    2021 arXiv

  10. [18]

    Remarks on matsumoto and amano’s normal form for single-qubit clifford+ t operators

    Brett Giles and Peter Selinger. Remarks on matsumoto and amano’s normal form for single-qubit clifford+ t operators. arXiv preprint arXiv:1312.6584, 2013

    2013 arXiv

  11. [19]

    Optimized quantum compilation for near-term algorithms with open- pulse

    Pranav Gokhale, Ali Javadi-Abhari, Nathan Earnest, Yunong Shi, and Frederic T Chong. Optimized quantum compilation for near-term algorithms with open- pulse. In 2020 53rd Annual IEEE/ACM International Symposium on Microarchitec- ture (MICRO), pages 186–200. IEEE, 2020

    2020

  12. [20]

    A fast quantum mechanical algorithm for database search

    Lov K Grover. A fast quantum mechanical algorithm for database search. arXiv preprint quant-ph/9605043, 1996

    1996 arXiv

  13. [21]

    Quantum algorithm for linear systems of equations

    Aram W Harrow, Avinatan Hassidim, and Seth Lloyd. Quantum algorithm for linear systems of equations. Physical review letters, 103(15):150502, 2009

    2009

  14. [22]

    A verified optimizer for quantum circuits

    Kesha Hietala, Robert Rand, Shih-Han Hung, Xiaodi Wu, and Michael Hicks. A verified optimizer for quantum circuits. Proceedings of the ACM on Programming Languages, 5(POPL):1–29, 2021

    2021

  15. [23]

    Exact and practical pattern matching for quantum circuit optimization

    Raban Iten, Romain Moyard, Tony Metger, David Sutter, and Stefan Woerner. Exact and practical pattern matching for quantum circuit optimization. ACM Transactions on Quantum Computing , 3(1):1–41, 2022

    2022

  16. [24]

    Opti- mization of quantum circuit mapping using gate transformation and commuta- tion

    Toshinari Itoko, Rudy Raymond, Takashi Imamichi, and Atsushi Matsuo. Opti- mization of quantum circuit mapping using gate transformation and commuta- tion. Integration, 70:43–50, 2020

    2020

  17. [25]

    Identity check is qma- complete, 2003

    Dominik Janzing, Pawel Wocjan, and Thomas Beth. Identity check is qma- complete, 2003

    2003

  18. [26]

    Cartan decomposition of su (2n) and control of spin systems

    Navin Khaneja and Steffen J Glaser. Cartan decomposition of su (2n) and control of spin systems. Chemical Physics, 267(1-3):11–23, 2001

    2001

  19. [27]

    PyZX: Large Scale Automated Dia- grammatic Reasoning

    Aleks Kissinger and John van de Wetering. PyZX: Large Scale Automated Dia- grammatic Reasoning. In Bob Coecke and Matthew Leifer, editors, Proceedings 16th International Conference on Quantum Physics and Logic, Chapman Univer- sity, Orange, CA, USA., 10-14 June 2019, volume 31...

    2019

  20. [28]

    Superconducting qubits: Current state of play

    Morten Kjaergaard, Mollie E Schwartz, Jochen Braumüller, Philip Krantz, Joel I-J Wang, Simon Gustavsson, and William D Oliver. Superconducting qubits: Current state of play. Annual Review of Condensed Matter Physics , 11(1):369–395, 2020

    2020

  21. [29]

    Quantum search compiler (qsearch) v2.0, version v2.0, 10 2020

    Costin Lancu, Marc Davis, Ethan Smith, and USDOE. Quantum search compiler (qsearch) v2.0, version v2.0, 10 2020

    2020

  22. [30]

    Qasmbench: A low-level qasm benchmark suite for nisq evaluation and simulation

    Ang Li, Samuel Stein, Sriram Krishnamoorthy, and James Ang. Qasmbench: A low-level qasm benchmark suite for nisq evaluation and simulation. arXiv preprint arXiv:2005.13018, 2021

    2005 arXiv

  23. [31]

    Tackling the qubit mapping problem for nisq-era quantum devices

    Gushu Li, Yufei Ding, and Yuan Xie. Tackling the qubit mapping problem for nisq-era quantum devices. In Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems, pages 1001–1014, 2019

    2019

  24. [32]

    Quarl: A learning-based quantum circuit optimizer

    Zikun Li, Jinjun Peng, Yixuan Mei, Sina Lin, Yi Wu, Oded Padon, and Zhihao Jia. Quarl: A learning-based quantum circuit optimizer. Proceedings of the ACM on Programming Languages, 8(OOPSLA1):555–582, 2024

    2024

  25. [33]

    Determining the minimal number of swap gates for multi-dimensional nearest neighbor quantum circuits

    Aaron Lye, Robert Wille, and Rolf Drechsler. Determining the minimal number of swap gates for multi-dimensional nearest neighbor quantum circuits. In The 20th Asia and South Pacific Design Automation Conference , pages 178–183. IEEE, 2015

    2015

  26. [34]

    Qubit mapping and routing via maxsat

    Abtin Molavi, Amanda Xu, Martin Diges, Lauren Pick, Swamit Tannu, and Aws Albarghouthi. Qubit mapping and routing via maxsat. In 2022 55th IEEE/ACM International Symposium on Microarchitecture (MICRO) , pages 1078–1091. IEEE, 2022

    2022

  27. [35]

    Programmable quantum simulations of spin systems with trapped ions

    Christopher Monroe, Wes C Campbell, L-M Duan, Z-X Gong, Alexey V Gorshkov, Paul W Hess, Rajibul Islam, Kihwan Kim, Norbert M Linke, Guido Pagano, et al. Programmable quantum simulations of spin systems with trapped ions. Reviews of Modern Physics, 93(2):025001, 2021

    2021

  28. [36]

    S. A. Moses, C. H. Baldwin, M. S. Allman, R. Ancona, L. Ascarrunz, C. Barnes, J. Bartolotta, B. Bjork, P. Blanchard, M. Bohn, J. G. Bohnet, N. C. Brown, N. Q. Burdick, W. C. Burton, S. L. Campbell, J. P. Campora III au2, C. Carron, J. Cham- bers, J. W. Chan, Y. H. Chen, A. Che...

    2023

  29. [37]

    Noise-adaptive compiler mappings for noisy intermediate- scale quantum computers

    Prakash Murali, Jonathan M Baker, Ali Javadi-Abhari, Frederic T Chong, and Margaret Martonosi. Noise-adaptive compiler mappings for noisy intermediate- scale quantum computers. In Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programmin...

    2019

  30. [38]

    Ross, Yuan Su, Andrew M

    Yunseong Nam, Neil J. Ross, Yuan Su, Andrew M. Childs, and Dmitri Maslov. Automated optimization of large quantum circuits with continuous parameters. npj Quantum Information, 4(1), may 2018

    2018

  31. [39]

    Quantum computation and quantum information, 2002

    Michael A Nielsen and Isaac Chuang. Quantum computation and quantum information, 2002

    2002

  32. [40]

    Decomposing and routing quantum circuits under constraints for neutral atom architectures

    Natalia Nottingham, Michael A Perlin, Ryan White, Hannes Bernien, Frederic T Chong, and Jonathan M Baker. Decomposing and routing quantum circuits under constraints for neutral atom architectures. arXiv preprint arXiv:2307.14996, 2023

    2023 arXiv

  33. [41]

    Reinforcement learning for optimization of variational quantum circuit architectures

    Mateusz Ostaszewski, Lea M Trenkwalder, Wojciech Masarczyk, Eleanor Scerri, and Vedran Dunjko. Reinforcement learning for optimization of variational quantum circuit architectures. Advances in Neural Information Processing Systems, 34:18182–18194, 2021

    2021

  34. [42]

    A variational eigenvalue solver on a photonic quantum processor

    Alberto Peruzzo, Jarrod McClean, Peter Shadbolt, Man-Hong Yung, Xiao-Qi Zhou, Peter J Love, Alán Aspuru-Guzik, and Jeremy L O’brien. A variational eigenvalue solver on a photonic quantum processor. Nature communications, 5:4213, 2014

    2014

  35. [43]

    Quantum computing in the nisq era and beyond

    John Preskill. Quantum computing in the nisq era and beyond. Quantum, 2:79, 2018

    2018

  36. [44]

    Beyond nisq: The megaquop machine, 2024

    John Preskill. Beyond nisq: The megaquop machine, 2024

    2024

  37. [45]

    Quantum simulation of 2d antiferromag- nets with hundreds of rydberg atoms

    Pascal Scholl, Michael Schuler, Hannah J Williams, Alexander A Eberhar- ter, Daniel Barredo, Kai-Niklas Schymik, Vincent Lienhard, Louis-Paul Henry, Thomas C Lang, Thierry Lahaye, et al. Quantum simulation of 2d antiferromag- nets with hundreds of rydberg atoms. Nature, 595(78...

    2021

  38. [46]

    An introduction to quantum machine learning

    Maria Schuld, Ilya Sinayskiy, and Francesco Petruccione. An introduction to quantum machine learning. Contemporary Physics, 56(2):172–185, 2015

    2015

  39. [47]

    Optimized compilation of aggregated in- structions for realistic quantum computers

    Yunong Shi, Nelson Leung, Pranav Gokhale, Zane Rossi, David I Schuster, Henry Hoffmann, and Frederic T Chong. Optimized compilation of aggregated in- structions for realistic quantum computers. In Proceedings of the Twenty-Fourth International Conference on Architectural Suppo...

    2019

  40. [48]

    Algorithms for quantum computation: Discrete logarithms and factoring

    Peter W Shor. Algorithms for quantum computation: Discrete logarithms and factoring. In Proceedings 35th annual symposium on foundations of computer science, pages 124–134. Ieee, 1994

    1994

  41. [49]

    Adap- tive pruning-based optimization of parameterized quantum circuits

    Sukin Sim, Jonathan Romero, Jérôme F Gonthier, and Alexander A Kunitsa. Adap- tive pruning-based optimization of parameterized quantum circuits. Quantum POPQC: Parallel Optimization for Quantum Circuits SPAA ’25, July 28–August 1, 2025, Portland, OR, USA Science and Technology...

    2025

  42. [50]

    Not all qubits are created equal: a case for variability-aware policies for nisq-era quantum computers

    Swamit S Tannu and Moinuddin K Qureshi. Not all qubits are created equal: a case for variability-aware policies for nisq-era quantum computers. In Proceed- ings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Syste...

    2019

  43. [51]

    An introduction to cartan’s kak decomposition for qc program- mers

    Robert R Tucci. An introduction to cartan’s kak decomposition for qc program- mers. arXiv preprint quant-ph/0507171, 2005

    2005 arXiv

  44. [52]

    Quantumnas: Noise-adaptive search for robust quantum circuits

    Hanrui Wang, Yongshan Ding, Jiaqi Gu, Yujun Lin, David Z Pan, Frederic T Chong, and Song Han. Quantumnas: Noise-adaptive search for robust quantum circuits. In 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA), pages 692–708. IEEE, 2022

    2022

  45. [53]

    Sam Westrick, Rohan Yadav, Matthew Fluet, and Umut A. Acar. Disentanglement in nested-parallel programs. In Proceedings of the 47th Annual ACM Symposium on Principles of Programming Languages (POPL) , 2020

    2020

  46. [54]

    Ibm’s qiskit tool chain: Working with and developing for real quantum computers

    Robert Wille, Rod Van Meter, and Yehuda Naveh. Ibm’s qiskit tool chain: Working with and developing for real quantum computers. In 2019 Design, Automation & Test in Europe Conference & Exhibition (DATE) , pages 1234–1240. IEEE, 2019

    2019

  47. [55]

    Qgo: Scalable quantum circuit optimization using automated synthesis

    Xin-Chuan Wu, Marc Grau Davis, Frederic T Chong, and Costin Iancu. Qgo: Scalable quantum circuit optimization using automated synthesis. arXiv preprint arXiv:2012.09835, 2020

    2012 arXiv

  48. [56]

    Tilt: Achieving higher fidelity on a trapped-ion linear-tape quantum computing architecture

    Xin-Chuan Wu, Dripto M Debroy, Yongshan Ding, Jonathan M Baker, Yuri Alex- eev, Kenneth R Brown, and Frederic T Chong. Tilt: Achieving higher fidelity on a trapped-ion linear-tape quantum computing architecture. In 2021 IEEE International Symposium on High-Performance Computer...

    2021

  49. [57]

    Synthesizing quantum-circuit optimizers

    Amanda Xu, Abtin Molavi, Lauren Pick, Swamit Tannu, and Aws Albarghouthi. Synthesizing quantum-circuit optimizers. Proc. ACM Program. Lang. , 7(PLDI), jun 2023

    2023

  50. [58]

    Optimizing quantum circuits, fast and slow

    Amanda Xu, Abtin Molavi, Swamit Tannu, and Aws Albarghouthi. Optimizing quantum circuits, fast and slow. arXiv preprint arXiv:2411.04104, 2024

    2024 arXiv

  51. [59]

    Acar, and Zhihao Jia

    Mingkuan Xu, Zikun Li, Oded Padon, Sina Lin, Jessica Pointing, Auguste Hirth, Henry Ma, Jens Palsberg, Alex Aiken, Umut A. Acar, and Zhihao Jia. Quartz: Superoptimization of quantum circuits. In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Langua...

    2022

  52. [60]

    Qfast: Conflating search and numerical optimization for scalable quantum circuit synthesis, 2021

    Ed Younis, Koushik Sen, Katherine Yelick, and Costin Iancu. Qfast: Conflating search and numerical optimization for scalable quantum circuit synthesis, 2021. SPAA ’25, July 28–August 1, 2025, Portland, OR, USA Pengyu Liu, Jatin Arora, Mingkuan Xu, and Umut A. Acar A ADDITIONAL...

    2021

Pith tools

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