Pith. sign in

REVIEW 2 major objections 4 minor 50 references

Clifford Circuit Synthesis for Distributed Quantum Architectures with Arbitrary Network Topology

T0 review · 2 major / 4 minor · reviewed 2026-08-14 · deepseek-v4-flash

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

Pith's one-line read Block-matrix Gaussian elimination compiles distributed CNOT and Clifford circuits with at most 2n(k−1) non-local gates on any connected partition topology, and matches the lower bound when k grows slowly relative to n.

desk verdict Solid distributed-CNOT/Clifford synthesis paper with a correct central theorem; the lower-bound constant needs a small fix but the asymptotics hold. read the letter →

arxiv 2608.13543 v1 pith:64MF2RND submitted 2026-08-13 quant-ph

Tuomas Laakkonen This is my paper · ORCID
classification quant-ph
keywords distributedquantumcomputingCliffordcircuitsynthesisCNOTgeneralizedgatesblockmatrixGaussianeliminationSteinertreeroutingstabilizertableauCSScodes
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

This paper claims that distributing a quantum circuit over $k$ blocks need not cost many extra non-local operations: for $n$ qubits split into $k$ equal partitions, both CNOT circuits and full Clifford circuits can be resynthesized with at most $2n(k-1)$ non-local gates, for any connected graph between the partitions. When the number of partitions is small relative to the number of qubits ($k=o(n/\log n)$), the paper proves this bound is asymptotically optimal, and for $k=2$ it gives a factor-2 approximation for every input circuit. The construction works by viewing the parity matrix (or stabilizer tableau) as a block matrix and performing Gaussian elimination on blocks, where each block operation is realized with generalized CNOT gates that cost one physical non-local CNOT each. A reader should care because non-local gates dominate time and error budgets in modular fault-tolerant quantum computers and block-code architectures, so a connectivity-independent formula for their minimum is a practical compilation target.

What carries the argument

The load-bearing object is the generalized CNOT gate $C(A,B)=e^{i\pi/4 (A\wedge B)}$, a Clifford gate between two partitions whose Pauli strings $A$ and $B$ can be made to look like $Z$ and $X$ by local Cliffords, so each one costs exactly one physical non-local CNOT. The algorithm's workhorse is the block row addition on a parity matrix or tableau: a binary coefficient matrix $R$ describing which rows of one partition are added to rows of another. ZX-type generalized CNOT gates act as rank-one block row additions, and the rank factorization of $R$ turns any block row addition into $\mathrm{rank}(R)$ such gates. Steiner trees route the elimination through the partition connectivity graph while the row-space lemmas maintain the required inclusions, and for Clifford circuits a symplectic analogue supplies the anticommuting Pauli strings needed to disentangle one partition at a time.

What would settle it

Pick two partitions of size $n/k \ge 2$, choose random Pauli strings $A$ and $B$, and synthesize the generalized CNOT gate $C(A,B)$ down to physical CNOTs using the local-Clifford construction of [15]; if any such gate requires more than one CNOT between the partitions, then the quantity being minimized is not the physical non-local gate count, and the paper's bounds and optimality theorems would be stated about the wrong quantity.

Watch

Extended reading notes

Core claim

The central discovery is that the hard part of distributed CNOT synthesis—eliminating the interaction between partitions—reduces to block Gaussian elimination on the parity matrix. Off-diagonal blocks are cleared by block row additions, and a ZX-type generalized CNOT gate performs exactly a rank-one block row addition, so any block row addition with coefficient matrix $R$ costs $\mathrm{rank}(R)$ such gates. The resulting algorithms, BlockRowCol and its Clifford analogue DistRowCol working on stabilizer tableaux, use at most $2n(k-1)$ non-local gates on any connected inter-partition graph; the paper proves this as Theorems 3.1 and 4.1. A counting argument shows this is asymptotically optimal whenever $k=o(n/\log n)$, and running the better of this method and standard linear-reversible synthesis is asymptotically optimal for every $k$. For $k=2$ the algorithm is within a factor of two of optimal on every input. The representation also extends to Clifford+RZ circuits by generalizing the Pauli exponential representation, and to CSS codes, where any logical CNOT circuit can be implemented with $O(k^2)$ inter-block transversal CNOTs and $O(nk)$ intra-block Pauli measurements.

Load-bearing premise

The cost model assumes every generalized CNOT gate $C(A,B)$ can be implemented with exactly one non-local CNOT plus local Clifford operations; if that implementation ever required a non-constant number of non-local CNOTs, the $2n(k-1)$ bounds, the CSS-code operation counts, and the asymptotic optimality claims would all need to be rescaled.

Editorial extensions

If this is right

  • For any connected graph between partitions, every CNOT circuit on $n$ qubits in $k$ blocks can be compiled to at most $2n(k-1)$ non-local gates, and when $k=o(n/\log n)$ no asymptotically better worst-case bound is possible.
  • The same $2n(k-1)$ guarantee holds for full Clifford circuits through DistRowCol, independent of inter-partition connectivity.
  • For $k=2$, BlockRowCol is a factor-2 approximation of the optimal non-local gate count for every individual CNOT circuit, not just in the worst case.
  • In a CSS code with one ancilla per block, any logical CNOT circuit can be implemented with at most $6k(k-1)$ inter-block transversal CNOTs and $O(nk)$ intra-block Pauli measurements, regardless of inter-block connectivity.
  • For Clifford+RZ circuits with $r$ phase gates, the distribution procedure introduces at most $2(k-1)(r+n)$ generalized CNOT gates, and the representation plugs into phase-folding and T-count optimization.

Reading between the lines

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

  • Beyond the paper: because block row addition is a generic primitive on parity matrices and tableaux, other synthesis engines—SAT-based, template-based, or peephole optimizers—could likely be given the same block treatment rather than being restricted to Gaussian elimination.
  • Beyond the paper: the CSS-code translation suggests a compiler recipe for any code with a transversal gate: express block row additions in that inter-block primitive and pay a cost depending on the number of blocks rather than the number of qubits, which could generalize to codes with other transversal primitives.
  • Beyond the paper: the benchmarks' suggestion that Clifford+RZ resynthesis rarely beats the input circuit points to a testable hypothesis—for T-rich circuits the bottleneck is phase structure, not inter-block connectivity—which could be checked by fixing T-count and increasing block size while watching whether non-local gates per phase gate saturate.
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

2 major / 4 minor

Summary. This paper develops methods for minimizing non-local gates in distributed CNOT, Clifford, and Clifford+RZ circuits when qubits are partitioned into k blocks with arbitrary inter-block connectivity. The central construction is a representation in which non-local Clifford operations are written as generalized CNOT gates C(A,B), each costing one physical non-local CNOT. The main results are BlockRowCol for CNOT circuits and DistRowCol for Clifford circuits, both using at most 2n(k−1) generalized CNOT gates regardless of partition connectivity, with a counting lower bound showing asymptotic optimality when k=o(n/log n), and a constant-factor approximation for k=2. The paper also presents a Clifford+RZ resynthesis heuristic with generalized-CNOT folding, a DAG bin-packing method for finding Clifford/CNOT subcircuits, benchmarks against pytket-dqc, and applications to CSS codes, phantom codes, the bicycle architecture, and tree tensor networks.

Significance. Assuming the main theorems are correct, this is a substantial contribution to distributed quantum compilation: it replaces topology-dependent routing heuristics with a tableau/linear-algebra method whose non-local gate count depends only on n and k, rather than on the inter-block graph. The proofs are explicit and the pseudocode is complete enough to reimplement; the counting lower bounds are parameter-free, and the claims are accompanied by a public implementation and benchmarks. The paper is appropriately cautious about the Clifford+T regime, where it reports worse performance than existing tools. The main advertised asymptotic claim concerns k=o(n/log n), and for that regime the argument is convincing. The main weaknesses are an overreach in the 'any k' optimality theorem and an error in the tree tensor network application.

major comments (2)
  1. [§3.4, Theorem 3.2 (and §4.3, Theorem 4.1)] The claim that running Patel–Markov–Hayes (or Aaronson–Gottesman) and choosing the better result gives asymptotic optimality for any value of k is not supported for arbitrarily restricted partition connectivity. Those algorithms synthesize circuits in an all-to-all qubit model; when k is large and the partition graph is not complete, their output can contain CNOTs between non-adjacent partitions, which are not valid non-local gates in the stated architecture. As written, the theorem either needs an explicit all-to-all connectivity assumption for this sentence, or it needs a connectivity-respecting O(n^2/log n) synthesis algorithm. The k=O(n/log n) part of the theorem is unaffected.
  2. [§8.4] The cost model for tree tensor networks is inconsistent. With n=2^a leaves and the cited scaling 2^{2l}, a highest-level gate (l≈a) has cost polynomial in n, not 2^{n/2}; writing '2^{n/2}' for the cost and calling 2^{2l} 'super-exponential' does not follow. The recurrence and the claimed O(2^{n/2} n log n) bound therefore need to be redone. The qualitative comparison with Patel–Markov–Hayes may survive with different exponents, but the current asymptotic statement is not justified.
minor comments (4)
  1. [§3.4, Lemma 3.7] The count of possible generalized CNOT gates uses 4^{n/k} for each Pauli string, but P^±_{n/k} has 2·4^{n/k} elements; the constant in the lower-bound estimate should be adjusted. The asymptotic conclusion is unchanged.
  2. [§2] The condition 'i_1 ≠ ±I_2' appears to be a typo for i_1 ≠ i_2.
  3. [§8.4] The phrase 'super-exponential in the level' misdescribes 2^{2l}, which is exponential in l.
  4. [§3.4, discussion before Theorem 3.3] The statement that non-ZX-type gates provide no benefit for CNOT unitaries is phrased as an expectation based on [31]; please state explicitly that Theorem 3.3 is restricted to ZX-type circuits and that the broader optimality claim is conditional.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the derivation is self-contained, with no fitted parameters, renamed inputs, or load-bearing self-citations.

full rationale

The central claims follow from rank-factorization and counting arguments: Theorem 3.1 uses Lemma 3.4 (any block row addition can be realized by rank(R) ZX-type generalized CNOT gates, with rank(R) ≤ n/k) and the 2k(k−1) block eliminations of BlockRowCol; Theorem 4.1 uses the analogous DistRowCol elimination. The lower bound in Lemma 3.7 is a counting bound that relies only on the elementary fact that any invertible parity matrix can be expressed as a CNOT circuit, with crossing CNOTs written as generalized CNOT gates; it does not reuse the algorithm being proved. The cost-model assumption that each generalized CNOT gate costs exactly one non-local CNOT is justified in Section 2.2 by local-Clifford conjugation of A to Z and B to X, with [15] as an external standard result and the construction sketched in the paper itself; this is not a circular ansatz. The only self-citation is [16], the public GitHub implementation used for benchmarks and scaling tests; it supplies no mathematical premise and is not load-bearing for Theorems 3.1, 3.2, 4.1, or 8.1. Lemma 5.1 is used only for optional CNOT-subcircuit detection, not for the main optimality claims. No equation is equal to its inputs by construction, and no predicted bound is a renamed fit.

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

The central claims rest on standard linear algebra, the Clifford and Pauli formalism, and the architectural assumptions that qubits are partitioned into k equal-sized connected modules. No free parameters are fitted to data; the only tunable quantities are heuristic choices such as beam width B in Section 5.3, which do not affect correctness or the stated bounds.

assumptions (6)
  • domain assumption Generalized CNOT gates C(A,B) can be implemented with exactly one non-local CNOT plus local Cliffords.
    Invoked in Section 2.2; links the generalized CNOT count to the physical non-local gate count.
  • domain assumption The partition connectivity graph is connected, and a non-articulation point can always be chosen at each elimination step.
    Required by Algorithms 3.5 and 4.3; ensures the induced graph stays connected.
  • domain assumption All partitions have equal size n/k.
    Theorems 3.1 and 4.1 assume equal-sized partitions; the block rank bounds depend on block size n/k.
  • standard math Standard F2 linear algebra facts: rank factorization, row and column operations, block inversion identities in Lemmas 3.1, 3.2, 3.4 through 3.6.
    Foundation of the elimination algorithms.
  • standard math Polynomial-time constant-factor Steiner tree approximations exist, and any tree subgraph of the induced graph has at most k-1 edges.
    Used in BlockElimCol; the edge bound keeps the 2n(k-1) count valid even with approximations.
  • standard math Stabilizer tableau facts: any anticommuting Pauli pair maps to Z1 and X1; centralizer dimension bounds of Lemmas 4.1 and 4.3.
    Used in Section 4 to construct disentangling gates.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Clifford Circuit Synthesis for Distributed Quantum Architectures with Arbitrary Network Topology." pith.science (2026). https://pith.science/paper/64MF2RND

@misc{pith2026260813543,
  author       = {Pith},
  title        = {Pith review of: Clifford Circuit Synthesis for Distributed Quantum Architectures with Arbitrary Network Topology},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/64MF2RND}},
  note         = {Machine review of arXiv:2608.13543}
}
read the original abstract

To achieve large-scale fault-tolerant quantum computation, it may be easier to combine many small sets of qubits than to construct a single large set. For example via quantum error correction with block codes, or distributed quantum processors utilizing shared entanglement. In these regimes, the time or error budget of the overall quantum computation may be dominated by non-local operations. Hence, it is worthwhile to minimize the number of these operations. We consider the case where both non-local and local connectivity may be arbitrarily restricted, and give an asymptotically optimal synthesis method for distributed CNOT and Clifford circuits, based on block-matrix Gaussian elimination. We extend this to all Clifford+RZ circuits by generalizing the Pauli exponential circuit representation; this naturally integrates with existing methods for optimizing T-count. As an application, we show how to implement CNOT circuits in a CSS code encoding n logical qubits in k blocks using O(nk) inter-block transversal CNOTs and intra-block Pauli measurements.

Figures

Figures reproduced from arXiv: 2608.13543 by the authors.

Figure 1
Figure 1. An example of how the a CNOT circuit is optimized using the methods presented in this paper. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. An example of translating a Clifford+T circuit into the representation defined in Section [PITH_FULL_IMAGE:figures/full_fig_p009_2.png] view at source ↗
Figure 3
Figure 3. An example of applying Algorithm 3.4 to a set of nine partitions connected in a 3x3 grid. (a) Suppose we have a parity matrix with non-zero blocks on five partitions, which we wish to eliminate using the pivot vertex (shown in white). (b) First, we construct the Steiner tree connecting the non-zero blocks and the pivot, and orient the edges away from the pivot. (c) By applying Lemma 3.6 repeatedly, we modify the blo… view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: An example of applying Algorithm 3.5 to a 4 × 4 parity matrix M with two partitions. (a) First, we eliminate the off-diagonal block in the first column of M using two block row additions; one to ensure that rsp(M21) ⊆ rsp(M11) and the second to eliminate M21. (b) Now w…
Figure 5
Figure 5. Figure 5: An example of different types of partitions of a DAG, as defined in Definition [PITH_FULL_IMAGE:figures/full_fig_p028_5.png]
Figure 6
Figure 6. Figure 6: A comparison of distributed CNOT circuit synthesis methods. [PITH_FULL_IMAGE:figures/full_fig_p034_6.png]
Figure 7
Figure 7. Figure 7: A comparison of distributed Clifford circuit synthesis methods. [PITH_FULL_IMAGE:figures/full_fig_p035_7.png]
Figure 8
Figure 8. Figure 8: A comparison of distributed Clifford+T circuit synthesis methods. [PITH_FULL_IMAGE:figures/full_fig_p035_8.png]
Figure 9
Figure 9. Figure 9: A comparison of the average total runtime used by each of the three distributed CNOT circuit [PITH_FULL_IMAGE:figures/full_fig_p036_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

50 extracted references · 35 canonical work pages

  1. [1]

    Distributed quantum computing: A survey

    Marcello Caleffi, Michele Amoretti, Davide Ferrari, Jessica Illiano, Antonio Manzalini, and Angela Sara Cacciapuoti. “Distributed quantum computing: A survey”. Computer Networks 254, 110672 (2024)

    2024

  2. [2]

    Distributed quantum computing across an optical network link

    D. Main, P. Drmota, D. P. Nadlinger, E. M. Ainley, A. Agrawal, B. C. Nichol, R. Srinivas, G. Araneda, and D. M. Lucas. “Distributed quantum computing across an optical network link”. Nature638, 383–388 (2025)

    work page 2025

  3. [3]

    Tour de gross: A modular quantum computer based on bivariate bicycle codes

    Theodore J. Yoder, Eddie Schoute, Patrick Rall, Emily Pritchett, Jay M. Gambetta, An- drew W. Cross, Malcolm Carroll, and Michael E. Beverland. “Tour de gross: A modular quantum computer based on bivariate bicycle codes” (2025). [2506.03094]

    arXiv 2025

  4. [4]

    Distributed arith- metic on a quantum multicomputer

    Rodney Van Meter, Kae Nemoto, W. J. Munro, and Kohei M. Itoh. “Distributed arith- metic on a quantum multicomputer”. ACM SIGARCH Computer Architecture News34, 354–365 (2006)

    work page 2006

  5. [5]

    Distributing circuits over heterogeneous, mod- ular quantum computing network architectures

    Pablo Andres-Martinez, Tim Forrer, Daniel Mills, Jun-Yi Wu, Luciana Henaut, Kentaro Ya- mamoto, Mio Murao, and Ross Duncan. “Distributing circuits over heterogeneous, mod- ular quantum computing network architectures”. Quantum Science and Technology9, 045021 (2024)

    work page 2024

  6. [6]

    Entanglement-efficient bipartite-distributed quantum com- puting

    Jun-Yi Wu, Kosuke Matsui, Tim Forrer, Akihito Soeda, Pablo Andr´ es-Mart ´ ınez, Daniel Mills, Luciana Henaut, and Mio Murao. “Entanglement-efficient bipartite-distributed quantum com- puting”. Quantum7, 1196 (2023)

    work page 2023

  7. [7]

    Distribution of quantum circuits over general quantum networks

    Ranjani G. Sundaram, Himanshu Gupta, and C. R. Ramakrishnan. “Distribution of quantum circuits over general quantum networks”. In 2022 IEEE International Conference on Quantum Computing and Engineering (QCE). Page 415–425. IEEE (2022)

    work page 2022

  8. [8]

    Picturing Quantum Software: An Introduction to the ZX-Calculus and Quantum Compilation

    Aleks Kissinger and John van de Wetering. “Picturing Quantum Software: An Introduction to the ZX-Calculus and Quantum Compilation”. Preprint. (2024). url:https://zxcalc. github.io/book/

    work page 2024

Show all 50 references
  1. [9]

    A game of surface codes: Large-scale quantum computing with lattice surgery

    Daniel Litinski. “A game of surface codes: Large-scale quantum computing with lattice surgery”. Quantum3, 128 (2019)

    2019

  2. [10]

    Improved simulation of stabilizer circuits

    Scott Aaronson and Daniel Gottesman. “Improved simulation of stabilizer circuits”. Physical Review A70(2004)

    2004

  3. [11]

    Optimization of cnot circuits on limited-connectivity architecture

    Bujiao Wu, Xiaoyu He, Shuai Yang, Lifu Shou, Guojing Tian, Jialin Zhang, and Xiaoming Sun. “Optimization of cnot circuits on limited-connectivity architecture”. Physical Review Research5(2023)

    2023

  4. [12]

    Architecture-aware synthesis of stabilizer circuits from clifford tableaus

    David Winderl, Qunsheng Huang, Arianne Meijer-van de Griend, and Richie Yeung. “Architecture-aware synthesis of stabilizer circuits from clifford tableaus” (2023). [2309.08972]

    2023 arXiv

  5. [13]

    Quantum circuit optimizations for nisq architectures

    Beatrice Nash, Vlad Gheorghiu, and Michele Mosca. “Quantum circuit optimizations for nisq architectures”. Quantum Science and Technology5, 025010 (2020)

    2020

  6. [14]

    Phase polynomials synthesis algorithms for nisq architectures and beyond

    Vivien Vandaele, Simon Martiel, and Timoth´ ee Goubault de Brugi` ere. “Phase polynomials synthesis algorithms for nisq architectures and beyond”. Quantum Science and Technology7, 045027 (2022). 40

    2022

  7. [15]

    A simple method for sampling random clifford operators

    Ewout van den Berg. “A simple method for sampling random clifford operators” (2020). [2008.06011]

    2020 arXiv

  8. [16]

    “dgpe”.https://github.com/tlaakkonen/dgpe(2026)

    Tuomas Laakkonen. “dgpe”.https://github.com/tlaakkonen/dgpe(2026)

    2026

  9. [17]

    How to factor 2048 bit rsa integers with less than a million noisy qubits

    Craig Gidney. “How to factor 2048 bit rsa integers with less than a million noisy qubits” (2025). [2505.15917]

    2025 arXiv

  10. [18]

    Entangling logical qubits without physical operations

    Jin Ming Koh, Anqi Gong, Andrei C. Diaconu, Daniel Bochen Tan, Alexandra A. Geim, Michael J. Gullans, Norman Y. Yao, Mikhail D. Lukin, and Shayan Majidy. “Entangling logical qubits without physical operations” (2026). [2601.20927]

    2026

  11. [19]

    Sim- ulating quantum circuits using tree tensor networks

    Philipp Seitz, Ismael Medina, Esther Cruz, Qunsheng Huang, and Christian B. Mendl. “Sim- ulating quantum circuits using tree tensor networks”. Quantum7, 964 (2023)

    2023

  12. [20]

    An introduction to quantum error correction and fault-tolerant quantum computation

    Daniel Gottesman. “An introduction to quantum error correction and fault-tolerant quantum computation” (2009). [0904.2557]

    2009 arXiv

  13. [21]

    Reducing the number of non-clifford gates in quantum circuits

    Aleks Kissinger and John van de Wetering. “Reducing the number of non-clifford gates in quantum circuits”. Physical Review A102(2020)

    2020

  14. [22]

    Optimizing t gates in clifford+t circuit as pi/4 rotations around paulis

    Fang Zhang and Jianxin Chen. “Optimizing t gates in clifford+t circuit as pi/4 rotations around paulis” (2019). [1903.12456]

    2019 arXiv

  15. [23]

    The classification of clifford gates over qubits

    Daniel Grier and Luke Schaeffer. “The classification of clifford gates over qubits”. Quantum 6, 734 (2022)

    2022

  16. [24]

    A comparison of quantum compilers using a dag-based or phase polynomial-based intermediate representation

    Arianne Meijer-van de Griend. “A comparison of quantum compilers using a dag-based or phase polynomial-based intermediate representation” (2023). [2304.08814]

    2023 arXiv

  17. [25]

    Nontrivial multi-product commutation relation toward reducing t-count in sequential pauli-based computation

    Yusei Mori, Hideaki Hakoshima, and Keisuke Fujii. “Nontrivial multi-product commutation relation toward reducing t-count in sequential pauli-based computation” (2025). [2509.20052]

    2025 arXiv

  18. [26]

    Cnot circuit extraction for topologically- constrained quantum memories

    Aleks Kissinger and Arianne Meijer-van de Griend. “Cnot circuit extraction for topologically- constrained quantum memories” (2019). [1904.00633]

    2019 arXiv

  19. [27]

    Efficient synthesis of linear reversible cir- cuits

    K. N. Patel, I. L. Markov, and J. P. Hayes. “Efficient synthesis of linear reversible cir- cuits” (2003). arXiv:quant-ph/0302002

    2003 arXiv

  20. [28]

    A fast algorithm for steiner trees

    L. Kou, G. Markowsky, and L. Berman. “A fast algorithm for steiner trees”. Acta Informatica 15, 141–145 (1981)

    1981

  21. [29]

    Improved steiner tree approximation in graphs

    Gabriel Robins and Alexander Zelikovsky. “Improved steiner tree approximation in graphs”. In Proceedings of the Eleventh Annual ACM-SIAM Symposium on Discrete Algorithms. Page 770–779. SODA ’00USA (2000). Society for Industrial and Applied Mathematics

    2000

  22. [30]

    Full rank factorization of matrices

    R. Piziak and P. L. Odell. “Full rank factorization of matrices”. Mathematics Magazine72, 193–201 (1999)

    1999

  23. [31]

    Hadamard-free circuits expose the structure of the clifford group

    Sergey Bravyi and Dmitri Maslov. “Hadamard-free circuits expose the structure of the clifford group”. IEEE Transactions on Information Theory67, 4546–4563 (2021)

    2021

  24. [32]

    An efficient quantum compiler that reducest count

    Luke Heyfron and Earl T. Campbell. “An efficient quantum compiler that reducest count” (2018). arXiv:1712.01557

    2018 arXiv

  25. [33]

    Dynamic transitive closure via dynamic matrix inverse (extended abstract)

    P. Sankowski. “Dynamic transitive closure via dynamic matrix inverse (extended abstract)”. In 45th Annual IEEE Symposium on Foundations of Computer Science. Page 509–517. IEEE (2004)

    2004

  26. [34]

    Acyclic partitioning of large directed acyclic graphs

    Julien Herrmann, Jonathan Kho, Bora Ucar, Kamer Kaya, and Umit V. Catalyurek. “Acyclic partitioning of large directed acyclic graphs”. In 2017 17th IEEE/ACM International Sym- posium on Cluster, Cloud and Grid Computing (CCGRID). IEEE (2017)

    2017

  27. [35]

    Breaking paragraphs into lines

    Donald E. Knuth and Michael F. Plass. “Breaking paragraphs into lines”. Software: Practice and Experience11, 1119–1184 (1981)

    1981

  28. [36]

    Reducing circuit depth with qubitwise diagonal- ization

    Edison M. Murairi and Michael J. Cervia. “Reducing circuit depth with qubitwise diagonal- ization”. Physical Review A108(2023)

    2023

  29. [37]

    Worst-case analysis of set union algorithms

    Robert E. Tarjan and Jan van Leeuwen. “Worst-case analysis of set union algorithms”. Journal of the ACM31, 245–281 (1984). 41

    1984

  30. [38]

    Quizx: a quick rust port of pyzx

    QuiZX Contributors. “Quizx: a quick rust port of pyzx”.https://github.com/zxcalc/ quizx(2019)

    2019

  31. [39]

    High-quality hypergraph partitioning

    Sebastian Schlag, Tobias Heuer, Lars Gottesb¨ uren, Yaroslav Akhremtsev, Christian Schulz, and Peter Sanders. “High-quality hypergraph partitioning”. ACM J. Exp. Algorithmics (2022)

    2022

  32. [40]

    Good quantum error-correcting codes exist

    A. R. Calderbank and Peter W. Shor. “Good quantum error-correcting codes exist”. Physical Review A54, 1098–1105 (1996)

    1996

  33. [41]

    The pinnacle architecture: Reducing the cost of breaking rsa-2048 to 100 000 physical qubits using quantum ldpc codes

    Paul Webster, Lucas Berent, Omprakash Chandra, Evan T. Hockings, Nou´ edyn Baspin, Felix Thomsen, Samuel C. Smith, and Lawrence Z. Cohen. “The pinnacle architecture: Reducing the cost of breaking rsa-2048 to 100 000 physical qubits using quantum ldpc codes” (2026). [2602.11457]

    2026 arXiv

  34. [42]

    Css codes are the only stabilizer codes with transversal cnot?

    Adam Zalcman. “Css codes are the only stabilizer codes with transversal cnot?”. Quan- tum Computing Stack Exchange (2023).https://quantumcomputing.stackexchange.com/ a/32823(Accessed: 2026-07-30)

    2023

  35. [43]

    Parallel logical measurements via quantum code surgery

    Alexander Cowtan, Zhiyang He, Dominic J. Williamson, and Theodore J. Yoder. “Parallel logical measurements via quantum code surgery”. PRX Quantum7(2026)

    2026

  36. [44]

    Decomposition of clifford gates

    Tefjol Pllaha, Kalle Volanto, and Olav Tirkkonen. “Decomposition of clifford gates”. In 2021 IEEE Global Communications Conference (GLOBECOM). Page 01–06. IEEE (2021)

    2021

  37. [45]

    Dynamic qubit routing with cnot circuit synthesis for quantum compilation

    Arianne Meijer-van de Griend and Sarah Meng Li. “Dynamic qubit routing with cnot circuit synthesis for quantum compilation”. Electronic Proceedings in Theoretical Computer Science 394, 363–399 (2023)

    2023

  38. [46]

    Tackling the qubit mapping problem for nisq-era quan- tum devices

    Gushu Li, Yufei Ding, and Yuan Xie. “Tackling the qubit mapping problem for nisq-era quan- tum devices”. In Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems. Page 1001–1014. ASPLOS ’19. ACM (2019)

    2019

  39. [47]

    Cnot-optimal clifford synthesis as sat

    Irfansha Shaik and Jaco van de Pol. “Cnot-optimal clifford synthesis as sat” (2025). [2504.00634]

    2025 arXiv

  40. [48]

    Architecture aware compilation of quan- tum circuits via lazy synthesis

    Simon Martiel and Timoth´ ee Goubault de Brugi` ere. “Architecture aware compilation of quan- tum circuits via lazy synthesis”. Quantum6, 729 (2022)

    2022

  41. [49]

    Clifford circuit opti- mization with templates and symbolic pauli gates

    Sergey Bravyi, Ruslan Shaydulin, Shaohan Hu, and Dmitri Maslov. “Clifford circuit opti- mization with templates and symbolic pauli gates”. Quantum5, 580 (2021)

    2021

  42. [50]

    Optimization of clifford circuits

    Vadym Kliuchnikov and Dmitri Maslov. “Optimization of clifford circuits”. Physical Review A88(2013). 42

    2013

Pith tools

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