Pith. sign in

REVIEW 4 major objections 6 minor 56 references

Resource Estimation for Fault-Tolerant Quantum Programs

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

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

Pith's one-line read Fault-tolerant quantum programs can be annotated with per-block error-correction schemes and estimated compositionally in space, time, and error.

desk verdict A genuine language-level contribution to FTQC resource estimation with a real, fixable gap between its headline 'conservative' claim and the heuristic joint-measurement cost model. read the letter →

arxiv 2608.04573 v1 pith:Q5CELL4I submitted 2026-08-05 quant-ph cs.PL

Bonan Su , Yuan Feng , Li Zhou , Mingsheng Ying This is my paper
classification quant-phcs.PL
keywords fault-tolerantquantumcomputingresourceestimationprogramminglanguageerrorcorrectionjointPaulimeasurementscodesurgerymagic-statedistillationdecodinglatency
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 tries to establish a middle path for fault-tolerant quantum programming: keep programs written at the logical level, but let the programmer attach a specific quantum error-correction scheme to each block of logical qubits, much as a classical type annotation fixes the size of a variable. It then derives physical resource use—number of physical qubits, execution time, and per-block error probability—through a compositional inference system that follows the program structure. The payoff is that different functional modules can use different codes or different code distances, and the trade-offs among space, time, and error become visible at the source level instead of being hidden in backend parameters. The paper demonstrates this on a logical T gate, a 15-to-1 magic-state distillation circuit, calibration against a general-purpose resource estimator, and a very large modular-inversion subroutine.

What carries the argument

The carrying mechanism is the resource-relation inference system: a compositional big-step judgment $(S,\Gamma)\Downarrow(\Gamma',T,N)$ in which the error context $\Gamma$ assigns each live codeblock (a set of logical qubits encoded together under one error-correction scheme) a scheme and a current failure probability. Rules for allocation, primitive operations, state preparation, measurement conditionals, sequencing, and parallelism update the context, with idle blocks accumulating memory errors through the estimate $\mathrm{Idle}_\Gamma(Q,T)=\lceil T/t_{\mathrm{SE}}\rceil\cdot p_L$. Cross-block interaction is carried by the joint Pauli measurement rule, which uses the universal-adapter construction for quantum LDPC codes: participating blocks are stitched into a deformed code of distance $d_{\mathrm{joint}}=\min_\ell d_\ell$, with estimated overheads $N_{\mathrm{joint}}=\mathrm{AncSE}_\Gamma(\mathrm{dom}(\Gamma))+\sum_\ell n_{\mathrm{aux}}^{(\ell)}+(a-1)\cdot 3d_{\mathrm{joint}}$, time $T_{\mathrm{meas}}=d_{\mathrm{joint}}\cdot\max_\ell 2\,t_{\mathrm{SE}}^{(\ell)}$, and decoding time $T_{\mathrm{dec}}=a\cdot\max_\ell t_{\mathrm{dec}}^{(\ell)}$. These formulas turn heterogeneous error correction into a manageable compositional accounting problem.

What would settle it

Measure a real joint logical measurement across two blocks encoded with different schemes or different distances, and compare the physical qubit count and syndrome-extraction cycles to the paper's bounds, namely at most $(a-1)\cdot 3 d_{\mathrm{joint}}$ adapter qubits, a factor-2 per-cycle time overhead, and decoding time $a\cdot\max_\ell t_{\mathrm{dec}}^{(\ell)}$; if the observed overhead exceeds those bounds, the conservative-estimate claim is false.

Watch

Extended reading notes

Core claim

The paper's central claim is that error-correction schemes belong in the programming language, not just in the estimator's configuration file. An allocation statement of the form logical q[m] := new<QEC> creates blocks of logical qubits bound to a named scheme, and the language rules make intra-block operations scheme-aware while cross-block operations are reduced to joint Pauli measurements. A big-step resource relation $(S,\Gamma)\Downarrow(\Gamma',T,N)$ then derives, for every statement, the elapsed time $T$, the auxiliary physical qubits $N$, and an updated error context $\Gamma'$ that tracks the failure probability of each live block. The paper reports that the resulting estimates match protocol-specific analyses up to a constant factor, closely track a general-purpose estimator on large circuits, and expose trade-offs such as assigning larger code distances to data qubits than to ancillas.

Load-bearing premise

The entire estimate assumes that stitching together differently encoded qubit blocks costs at most the small adapter overhead stated in the joint-measurement rules; if real stitching costs more, every cross-block resource estimate comes out too low.

Editorial extensions

If this is right

  • Programmers can annotate each codeblock with its own error-correction scheme or code distance, and the framework returns space, time, and error estimates that track the structure of the program, not a single global error-correction assumption.
  • Decoding latency is accounted for as a first-class cost: the language lets intermediate statements run during decoding, and choosing the 99.9th-percentile versus mean latency can change whether larger code distances actually reduce total error.
  • Hybrid code-distance assignments, with stronger protection for data qubits and weaker protection for ancillas, achieve lower error than uniform assignments under the same space budget, as demonstrated for the auto-corrected T gate.
  • For the 15-to-1 distillation protocol, the framework's estimates match the protocol-specific analysis in asymptotic scaling, with a constant-factor overhead from the generic, unoptimized implementation.
  • For large benchmark circuits, the space estimates closely match a general-purpose estimator, while time estimates are higher because joint measurements and decoding latency are included.
  • The extended-Euclidean-algorithm study suggests that whole-program fault-tolerant resource accounting at the scale of millions of source lines is computationally feasible, yielding roughly $2.12\times 10^6$ physical qubits and $3.5\times 10^9$ cycles for the 64-bit modular-inversion circuit considered.

Reading between the lines

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

  • The type-like treatment of error-correction schemes suggests an automated optimization pass that searches over code assignments and distances under a space or time budget, which the paper only explores by hand.
  • Because decoding latency is a first-class cost, a compiler could schedule commuting Clifford gates into the latency window for whole circuits, generalizing the hand-written auto-corrected T gate.
  • If the adapter cost model holds, the hybrid-distance strategy should extend beyond surface codes, for example mixing high-rate quantum LDPC storage blocks with a surface-code compute block, where adapter overhead is the dominant term.
  • The roughly 13-minute estimate for a multi-million-line modular-inversion program suggests that whole-program fault-tolerant estimation of complete algorithms, including their black-box subroutines, is computationally feasible.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 6 minor

Summary. The paper proposes a logical-level quantum programming language in which each allocated codeblock is annotated with an error-correction scheme, and in which joint Pauli measurements are the only cross-codeblock primitive. It defines a QEC/hardware interface (Sec. 4) and a compositional resource-relation inference system (Sec. 5) that derives space, time, and per-codeblock error estimates from the program and the scheme specifications. The framework is implemented in a prototype and evaluated on a logical T gate (Sec. 6.1), a 15-to-1 magic-state distillation circuit (Sec. 6.2), a comparison with Microsoft's QREv3 (Sec. 6.3), and an extended Euclidean algorithm subroutine (Sec. 6.4). The central claim is that programmer-visible QEC abstractions and cross-layer analysis enable substantial resource savings while delivering detailed, fine-grained, accurate, and conservative resource estimates.

Significance. If the cost model in Sec. 5.2.2 were fully justified, the framework would be a valuable contribution: it cleanly separates program structure from QEC-specific parameters, makes classical decoding latency a first-class resource, and the case studies demonstrate concrete uses of heterogeneous QEC choices, including error-rate improvements under fixed space budgets and a direct comparison with a general-purpose tool. The compositional inference rules in Sec. 5 are precisely stated, and the prototype appears to be a working artifact. However, the accuracy and conservativeness claims currently rest on heuristic bounds for joint Pauli measurements that are presented as upper bounds but are not proven, so the contribution is promising but requires additional justification before the central claim can be accepted at face value.

major comments (4)
  1. [Sec. 5.2.2, Eq. (5)] The adapter-qubit term (a-1)*3*d_joint in Eq. (5) is introduced as a heuristic upper bound, but the paper provides neither a proof nor a precise statement of the conditions under which the universal-adapter construction [49] can stitch a participating codeblocks using at most a-1 adapters of size 3*d_joint. Since joint Pauli measurements are used in every cross-codeblock operation in the case studies (including the CNOT construction in Example 3.1 and the a=4 measurement in Fig. 17), an optimistic adapter estimate would make all cross-codeblock space estimates optimistic. Please either derive the bound from [49], prove it, or explicitly state it as an assumption and re-evaluate the conservativeness claims accordingly.
  2. [Sec. 5.2.2, T_meas] The time estimate T_meas = d_joint * max_l 2*ceil(t_SE^(l)) is justified only by the assertion that the additional auxiliary-graph checks 'do not exceed the number of checks in the original codeblock.' This assertion is not derived from [49] and is especially unclear for a>2 stitched codeblocks; if the per-cycle factor is larger than 2, the time estimate is optimistic. The paper should either supply the derivation, verify the factor against a concrete implementation of the adapter construction, or treat the factor as a tunable parameter and report the sensitivity of the case-study conclusions to it.
  3. [Sec. 5.2.2, T_dec] The decoding-time estimate T_dec = a * max_l ceil(t_dec^(l)) assumes that the deformed-code decoding problem decomposes into at most a subproblems, each no harder than the most expensive participating codeblock. No evidence is given for this decomposition, and the text itself acknowledges that the decoding cost depends on the weight a of the measured operator. Because this term is load-bearing for the claimed 'conservative upper bound' on time across all joint measurements, it must be either proven, empirically demonstrated, or removed from the conservativeness claim. The current validation does not cover this term.
  4. [Secs. 6.2 and 6.3] The empirical validation does not directly close the gap left by the heuristic cost model. In Sec. 6.2, the 8.7x time overestimate relative to the protocol-specific analysis shows that the framework cannot capture the pipelining and surgery-reuse optimizations of [30], so that comparison does not validate the joint-measurement time or decoding terms. In Sec. 6.3, the comparison with QREv3 deliberately treats the logical T gate as a primitive, so the dominant non-Clifford operations are not exercised through the joint-measurement path; the remaining CNOT operations do exercise joint measurements, but the comparison is not decomposed to isolate the adapter and decoding heuristics. Please add a case study or sensitivity analysis that validates the joint-measurement cost model directly, for example by comparing against a literal lattice-surgery compilation of a small circuit, or explicitly state that the framework provides estimates that may be non-conservative for cross-codeblock operations.
minor comments (6)
  1. [Sec. 6.1, text vs Table 1] The text says the d=27,27 configuration requires 'approximately 2247 syndrome-extraction cycles and 3724 ancillary physical qubits,' while Table 1 reports 2247 cycles and 4453 physical qubits; please clarify whether 3724 is the non-codeblock overhead and make the total consistent.
  2. [Sec. 6.4, Eq. (7)] Equation (7) uses 10^9 cycles in the expression for the required number of physical qubits, whereas the text reports 3.5*10^9 cycles for the EEA circuit; please replace 10^9 with the actual cycle count or explain the approximation.
  3. [Fig. 5] Line 4 of Fig. 5 contains a stray semicolon in 'if M(ZZ)[q[0], anc];', which is inconsistent with the syntax in Fig. 6; the semicolon after the closing bracket should be removed.
  4. [Secs. 3.2 and 6.4] The manuscript references an appendix for the sliding-window decoding model and for the EEA setup, but no appendix is included in the submitted version; please either include it or remove the references.
  5. [Sec. 5.1] The rule for primitive logical operations charges AncSE(dom(Γ)) as part of the space cost, while the faulty-operation rule charges AncSE(dom(Γ) \ {q[i]}); the asymmetry is understandable (the faulty block does not perform syndrome extraction) but should be stated explicitly.
  6. [Sec. 4.2, Fig. 11] The specification naux = d^2 for surface codes is justified as a 'special case of auxiliary graph surgery' but no concrete derivation or specific citation to [49] is given; please provide an equation or reference for this estimate.

Circularity Check

1 steps flagged · score 2.0 of 10

Only mild circularity: the QREv3 comparison in Sec. 6.3 calibrates the framework's error model and configuration to the baseline before comparing, so that agreement is partly built from the same inputs; the rest of the derivation chain is independent and uses external parameters.

  1. fitted input called prediction [Sec. 6.3, 'Calibration Against Microsoft's Quantum Resource Estimator', Fig. 19]
    "We then calibrate the specifications and configurations in our framework to match those of QREv3, including the error model, and treat the logical 𝑇 gate as a primitive operation for consistency. ... Overall, the space-cost estimates produced by our framework are almost perfectly aligned with those of QREv3, with the minor discrepancy attributable to the different treatments of logical CNOT gates."

    The RQ3 validation imports QREv3's own error model, hardware configuration, and code distance into the framework before computing the estimates, and then reports that the estimates align with QREv3. This makes the agreement in Fig. 19 in significant part a propagation of identical inputs rather than an independent test of the framework's predictions. The choice to treat the logical T gate as a primitive also removes the framework's distinctive joint-Pauli-measurement machinery from the comparison. This is a mild, localized circularity: it affects only the QREv3 validation claim, and the other case studies use externally specified formulas from [18], [14], and [30] without tuning to reproduce the baseline.

full rationale

The paper's core derivation chain is compositional arithmetic over user-supplied QEC specifications, external hardware parameters, and external error-model formulas. The logical error rate p_L is taken from [18], the decoding latency is taken from experimental data in [14], and the joint Pauli measurement construction is taken from the external universal-adapter result [49]; none of these inputs is derived from the paper's own target outputs, so the framework's estimates are not self-definitional. The Section 5.2.2 cost formulas for joint Pauli measurements are explicitly labeled heuristics and are not proven upper bounds; if those heuristic terms are optimistic, the case-study estimates could be optimistic. That is a soundness/correctness concern, however, not circularity, because the paper does not present those heuristics as derived predictions. There is no load-bearing self-citation: the author's Floyd-Hoare reference [53] appears only in related work, and the universal-adapter paper [49] is by different authors. The Sec. 7 caveat that estimates 'may be conservative' is a limitation statement, not a derivation. The only genuinely circular flavor is the QREv3 comparison of Sec. 6.3, where the framework is deliberately calibrated to match the comparator's error model and settings before being compared with it; the agreement is therefore partly by construction, though the remaining space and time discrepancies are reported honestly. Overall the paper is largely self-contained against external benchmarks, with one mild calibration-based circularity, so a score of 2 is appropriate.

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

The framework's outputs are computed from a small set of externally imported parameters and positional heuristics. The key reliability question is whether the heuristics for joint Pauli measurements are true upper bounds; the paper states but does not prove them. No new physical entities are introduced.

free parameters (5)
  • p_L prefactor a and threshold p_th = a = 0.1, p_th = 0.0057
    Used in Fig. 11 line 13 and Section 6.4 as p_L = a * (max(p1,p2,pm)/p_th)^((d+1)/2). All logical error rates and optimal-distance tables inherit this formula, which is imported from [18] and not re-derived.
  • decoding time constant for d=27 = 255 * t_SE
    Fig. 11 line 12, taken from Fig. 2(b) of [14]. The mean and 99.9th-percentile curves in Fig. 14 are also read off [14]. Decoding latency is the main driver of memory-error accumulation and time cost.
  • adapter qubit bound = (a-1) * 3 * d_joint
    Equation (5), stated as a 'heuristically upper-bound' with no proof. Every joint Pauli measurement space cost depends on this term.
  • joint measurement time factor = 2
    T_meas = d_joint * max(2 * t_SE), described as a 'conservative heuristic' for the extra checks introduced by auxiliary graph surgery. This directly sets the time cost of all cross-codeblock measurements.
  • deformed-code decoding time multiplier = a (weight of measured Pauli operator)
    T_dec = a * max(t_dec^(l)), stated as a conservative upper bound assuming a fast modular decoder. If decoding does not decompose into at most a independent subproblems, this understates latency.
assumptions (6)
  • domain assumption Logical error rate per syndrome-extraction cycle follows p_L = a * (p/p_th)^((d+1)/2) with a = 0.1 and p_th = 0.0057 for surface codes.
    Borrowed from [18] and applied to all code distances 23-31 used in the case studies. The error-rate outputs are direct consequences of this formula.
  • domain assumption Decoding latency for surface-code measurement outcomes is given by the mean or 99.9th-percentile data of [14], and for deformed codes by T_dec = a * max(t_dec).
    The framework treats decoding latency as a key input; all measurement-based conditional costs and memory-error accumulation depend on these distributions, and the deformed-code estimate further assumes a fast modular decoder.
  • domain assumption Universal adapters from [49] can stitch arbitrary QEC codeblocks with resource costs bounded by n_aux, (a-1)*3*d_joint adapter qubits, and a factor-2 per-cycle overhead.
    Section 5.2.2. The joint Pauli measurement cost model assumes the adapter construction is available and that the stated heuristic bounds are true upper bounds.
  • domain assumption Idle codeblocks accumulate errors at rate ceil(T/t_SE) * p_L per idle interval, and independent failures combine via epsilon xor p.
    Equation (2) and the Step/Idle definitions in Section 5. The paper calls this a coarse but conservative approximation, but no formal upper-bound proof is given.
  • domain assumption Pauli frame tracking and sufficient parallel classical decoding capacity allow quantum execution to proceed without stalling except for measurement-based control.
    Section 3.2. If decoder throughput is insufficient, backlog would increase both time and memory errors, violating the estimates.
  • domain assumption Physical qubits are homogeneous and gates are characterized by single error rates and durations, as in the C tuple of Section 4.1.
    All space and time costs are computed from these coarse-grained hardware parameters. Layout, connectivity, and inhomogeneous qubit properties are not modeled.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Resource Estimation for Fault-Tolerant Quantum Programs." pith.science (2026). https://pith.science/paper/Q5CELL4I

@misc{pith2026260804573,
  author       = {Pith},
  title        = {Pith review of: Resource Estimation for Fault-Tolerant Quantum Programs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Q5CELL4I}},
  note         = {Machine review of arXiv:2608.04573}
}
read the original abstract

Fault-tolerant quantum computation enables the deployment of practical quantum algorithms but incurs substantial overhead from error correction, making resource estimation a central concern. Beyond case-by-case analyses, existing quantum programming languages either require programmers to manipulate low-level hardware details, rendering fault-tolerant implementations cumbersome, or abstract away the underlying error-correction schemes, reducing the effectiveness of resource utilization and estimation. To address these limitations while preserving programmability, we present a quantum programming language that enables efficient resource utilization, together with a resource-estimation framework for comprehensive resource analysis. Our framework features programmer-visible abstractions of error-correction schemes and cross-layer program-hardware analysis, allowing systematic exploration of resource trade-offs. We evaluate our approach on detailed fault-tolerant implementations of practical large-scale quantum algorithms, including components typically treated as black boxes in existing frameworks. The results demonstrate that our framework enables substantial resource savings while delivering detailed, fine-grained, and accurate resource estimates for fault-tolerant quantum programs.

Figures

Figures reproduced from arXiv: 2608.04573 by the authors.

Figure 1
Figure 1. Error-correction schemes assigned to different functional modules in an implementation of Shor’s [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Overall architecture of our resource estimation framework for fault-tolerant quantum programs. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Implementation of a logical 𝑆 gate using an ancilla in the state |𝑌⟩ := 𝑌 |+⟩. decoding latency [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (14 more)
Figure 5
Figure 5. Figure 5: Source code for the logical 𝑇 gate, where the call to the distillation protocol for preparing the magic state is temporarily commented out [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: Abstract syntax of the programming language. Here, [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Definition of ActBlock(𝑆), where ActBlock(𝑞) ≜ {𝑞[𝑖] | ∃𝑗, 𝑞[𝑖] [𝑗] ∈ 𝑞} extracts the codeblocks accessed in 𝑞. is resource estimation. The statements OP[𝑞] and M (𝑀) [𝑞] denote intra-codeblock primitive operations and measurements, respectively. They are well-formed o…
Figure 8
Figure 8. Figure 8: Compilation of program statements into dynamic fault-tolerant circuits. Each horizontal wire denotes [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]
Figure 9
Figure 9. Figure 9: Compiled circuit for the CNOT gate. Adjacent syndrome-extraction intervals are merged into longer [PITH_FULL_IMAGE:figures/full_fig_p008_9.png]
Figure 10
Figure 10. Figure 10: Execution of syndrome extraction with classical decoding. A sliding window of syndrome data is sent [PITH_FULL_IMAGE:figures/full_fig_p010_10.png]
Figure 11
Figure 11. Figure 11: An example of an error-correction scheme specification for the surface code with [PITH_FULL_IMAGE:figures/full_fig_p013_11.png]
Figure 12
Figure 12. Figure 12: Error propagation in a mea￾surement based if statement. The measurement-based conditional statement is the most sub￾tle case in resource estimation, since the measurement M may be either a specified primitive operation M = M (𝑀) or a cross-code joint Pauli measurement…
Figure 13
Figure 13. Figure 13: Auto-corrected implementation of a logical [PITH_FULL_IMAGE:figures/full_fig_p020_13.png]
Figure 14
Figure 14. Figure 14: Resource estimation for a logical 𝑇 gate followed by 36 logical Hadamard gates across different code distances, comparing the naive and auto-corrected implementations shown in Figs. 4 and 13, respectively. The two decoding-latency plots in the first column are adapted…
Figure 15
Figure 15. Figure 15: The 15-to-1 magic state distillation protocol, [PITH_FULL_IMAGE:figures/full_fig_p022_15.png]
Figure 17
Figure 17. Figure 17: Source code for the 15-to-1 magic state distillation circuit. [PITH_FULL_IMAGE:figures/full_fig_p023_17.png]
Figure 19
Figure 19. Figure 19: Comparison of space and time costs between Mi [PITH_FULL_IMAGE:figures/full_fig_p023_19.png]
Figure 20
Figure 20. Figure 20: Physical qubit requirements for ∼ 109 -cycle programs across hardware noise conditions and error budgets 𝜖. We additionally present a component-level study of a publicly available implementation of the extended Eu￾clidean algorithm (EEA) for modular inversion [33], wi…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

56 extracted references · 16 canonical work pages

  1. [49]

    Esha Swaroop, Tomas Jochym-O’Connor, and Theodore J. Yoder. 2026. Universal Adapters between Quantum Low- Density Parity Check Codes.PRX Quantum7 (Feb 2026), 010324. Issue 1. doi:10.1103/1g44-jp62

    doi:10.1103/1g44-jp62 2026

  2. [1]

    Parosh Aziz Abdulla, Yo-Ga Chen, Yu-Fang Chen, Lukáš Holík, Ondřej Lengál, Jyun-Ao Lin, Fang-Yi Lo, and Wei- Lun Tsai. 2025. Verifying Quantum Circuits with Level-Synchronized Tree Automata.Proceedings of the ACM on Programming Languages9, POPL (2025), 923–953. doi:10.1145/3704868

    doi:10.1145/3704868 2025

  3. [2]

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

    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, Johannes Bausch, Andreas Bengtsson, Alexander Bilmes, Sam Blackwell, Sergio Boixo, Gina Bortoli, Alexandre Bourassa,...

    2025

  4. [3]

    Aharonov and M

    D. Aharonov and M. Ben-Or. 1997. Fault-tolerant quantum computation with constant error. InProceedings of the Twenty-Ninth Annual ACM Symposium on Theory of Computing(El Paso, Texas, USA)(STOC ’97). Association for Resource Estimation for Fault-Tolerant Quantum Programs 27 Computing Machinery, New York, NY, USA, 176–188. doi:10.1145/258533.258579

    work page arXiv 1997

  5. [4]

    Ryan Babbush, Adam Zalcman, Craig Gidney, Michael Broughton, Tanuj Khattar, Hartmut Neven, Thiago Bergamaschi, Justin Drake, and Dan Boneh. 2026. Securing Elliptic Curve Cryptocurrencies against Quantum Vulnerabilities: Resource Estimates and Mitigations. arXiv:2603.28846 [quant-ph] https://arxiv.org/abs/2603.28846

    arXiv 2026

  6. [5]

    Beverland, Prakash Murali, Matthias Troyer, Krysta M

    Michael E. Beverland, Prakash Murali, Matthias Troyer, Krysta M. Svore, Torsten Hoefler, Vadym Kliuchnikov, Guang Hao Low, Mathias Soeken, Aarthi Sundaram, and Alexander Vaschillo. 2022. Assessing requirements to scale to practical quantum advantage. arXiv:2211.07629 [quant-ph] https://arxiv.org/abs/2211.07629

    arXiv 2022

  7. [6]

    Benjamin Bichsel, Maximilian Baader, Timon Gehr, and Martin Vechev. 2020. Silq: a high-level quantum language with safe uncomputation and intuitive semantics. InProceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation(London, UK)(PLDI 2020). Association for Computing Machinery, New York, NY, USA, 286–300. doi:10.114...

    arXiv 2020

  8. [7]

    Bombin and M

    H. Bombin and M. A. Martin-Delgado. 2006. Topological Quantum Distillation.Phys. Rev. Lett.97 (Oct 2006), 180501. Issue 18. doi:10.1103/PhysRevLett.97.180501

    doi:10.1103/physrevlett.97.180501 2006

Show all 56 references
  1. [8]

    Lokhov, Avanish Mishra, Sidhant Misra, Zachary Morrell, Zain Mughal, Duff Neill, Andrei Piryatinski, Allen Scheie, Marc Vuffray, and Yu Zhang

    Andreas Bärtschi, Francesco Caravelli, Carleton Coffrin, Jonhas Colina, Stephan Eidenbenz, Abhijith Jayakumar, Scott Lawrence, Minseong Lee, Andrey Y. Lokhov, Avanish Mishra, Sidhant Misra, Zachary Morrell, Zain Mughal, Duff Neill, Andrei Piryatinski, Allen Scheie, Marc Vuffra...

    2025 arXiv

  2. [9]

    Madelyn Cain, Qian Xu, Robbie King, Lewis R. B. Picard, Harry Levine, Manuel Endres, John Preskill, Hsin-Yuan Huang, and Dolev Bluvstein. 2026. Shor’s algorithm is possible with as few as 10,000 reconfigurable atomic qubits. arXiv:2603.28627 [quant-ph] https://arxiv.org/abs/2603.28627

    2026 arXiv

  3. [10]

    Campbell, Barbara M

    Earl T. Campbell, Barbara M. Terhal, and Christophe Vuillot. 2017. Roads towards fault-tolerant universal quantum computation.Nature549, 7671 (2017), 172–179. doi:10.1038/nature23460

    2017 doi

  4. [11]

    Yuang Charles. 2026. Cobble: Compiling Block Encodings for Quantum Computational Linear Algebra.Proceedings of the ACM on Programming Languages10, PLDI (June 2026). doi:10.1145/3808255

    2026 doi

  5. [12]

    Bishop, Steven Heidel, Colm A

    Andrew Cross, Ali Javadi-Abhari, Thomas Alexander, Niel De Beaudrap, Lev S. Bishop, Steven Heidel, Colm A. Ryan, Prasahnt Sivarajah, John Smolin, Jay M. Gambetta, and Blake R. Johnson. 2022. OpenQASM 3: A Broader and Deeper Quantum Assembly Language.ACM Transactions on Quantum...

    2022 doi

  6. [13]

    Cross, Zhiyang He, Patrick J

    Andrew W. Cross, Zhiyang He, Patrick J. Rall, and Theodore J. Yoder. 2025. Improved QLDPC Surgery: Logical Measurements and Bridging Codes. arXiv:2407.18393 [quant-ph] https://arxiv.org/abs/2407.18393

    2025

  7. [14]

    Nicolas Delfosse, Andres Paz, Alexander Vaschillo, and Krysta M. Svore. 2023. How to choose a decoder for a fault- tolerant quantum computer? The speed vs accuracy trade-off. arXiv:2310.15313 [quant-ph] https://arxiv.org/abs/2310. 15313

    2023 arXiv

  8. [15]

    Eric Dennis, Alexei Kitaev, Andrew Landahl, and John Preskill. 2002. Topological quantum memory.J. Math. Phys.43, 9 (2002), 4452–4505

    2002

  9. [16]

    Cirq Developers. 2025. Cirq. doi:10.5281/ZENODO.4062499

    2025 doi

  10. [17]

    Ellie D’hondt and Prakash Panangaden. 2006. Quantum weakest preconditions.Mathematical. Structures in Comp. Sci. 16, 3 (June 2006), 429–451. doi:10.1017/S0960129506005251

    2006 doi

  11. [18]

    Fowler, Matteo Mariantoni, John M

    Austin G. Fowler, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland. 2012. Surface codes: Towards practical large-scale quantum computation.Phys. Rev. A86 (Sep 2012), 032324. Issue 3. doi:10.1103/PhysRevA.86.032324

    2012 doi

  12. [19]

    Craig Gidney. 2025. Magic State Cultivation. Slides for Simons Institute Quantum Colloquium. https://simons.berkeley.edu/sites/default/files/2025-04/Magic%20State%20Cultivation%20-%20Simons%20Quantum% 20Colloquium%20April%202025.pdf Simons Institute for the Theory of Computing...

    2025

  13. [20]

    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

    doi

  14. [21]

    Craig Gidney, Noah Shutty, and Cody Jones. 2024. Magic state cultivation: growing T states as cheap as CNOT gates. arXiv:2409.17595 [quant-ph] https://arxiv.org/abs/2409.17595

    2024 arXiv

  15. [22]

    Daniel Gottesman. 2009. An Introduction to Quantum Error Correction and Fault-Tolerant Quantum Computation. arXiv:0904.2557 [quant-ph] https://arxiv.org/abs/0904.2557

    2009 arXiv

  16. [23]

    Green, Peter LeFanu Lumsdaine, Neil J

    Alexander S. Green, Peter LeFanu Lumsdaine, Neil J. Ross, Peter Selinger, and Benoît Valiron. 2013. Quipper: a scalable quantum programming language. InProceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation(Seattle, Washington, USA)(PL...

    2013

  17. [24]

    Harrigan, Tanuj Khattar, Charles Yuan, Anurudh Peduri, Noureldin Yosri, Fionn D

    Matthew P. Harrigan, Tanuj Khattar, Charles Yuan, Anurudh Peduri, Noureldin Yosri, Fionn D. Malone, Ryan Babbush, and Nicholas C. Rubin. 2024. Expressing and Analyzing Quantum Algorithms with Qualtran. arXiv:2409.04643 [quant- ph] https://arxiv.org/abs/2409.04643 28 Bonan Su, ...

    2024 arXiv

  18. [25]

    Wood, Jake Lishman, Julien Gacon, Simon Martiel, Paul D

    Ali Javadi-Abhari, Matthew Treinish, Kevin Krsulich, Christopher J. Wood, Jake Lishman, Julien Gacon, Simon Martiel, Paul D. Nation, Lev S. Bishop, Andrew W. Cross, Blake R. Johnson, and Jay M. Gambetta. 2024. Quantum computing with Qiskit. arXiv:2405.08810 [quant-ph] doi:10.4...

    2024 doi arXiv

  19. [26]

    Chong, and Margaret Martonosi

    Ali JavadiAbhari, Shruti Patil, Daniel Kudrow, Jeff Heckey, Alexey Lvov, Frederic T. Chong, and Margaret Martonosi

  20. [27]

    latticesurgery-com. 2026. Lattice Surgery Compiler. https://github.com/latticesurgery-com/lattice-surgery-compiler. GitHub repository

    2026

  21. [28]

    Tyler Leblond, Christopher Dean, George Watkins, and Ryan Bennink. 2024. Realistic Cost to Execute Practical Quantum Circuits using Direct Clifford+T Lattice Surgery Compilation.ACM Transactions on Quantum Computing5, 4 (Oct. 2024), 1–28. doi:10.1145/3689826

    2024 doi

  22. [29]

    Daniel Litinski. 2019. A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery.Quantum3 (March 2019), 128. doi:10.22331/q-2019-03-05-128

    2019 doi

  23. [31]

    Daniel Litinski and Felix von Oppen. 2018. Lattice Surgery with a Twist: Simplifying Clifford Gates of Surface Codes. Quantum2 (May 2018), 62. doi:10.22331/q-2018-05-04-62

    2018 doi

  24. [32]

    Han Luo, Ziyi Yang, Ziruo Wang, Yuexin Su, and Tongyang Li. 2026. eea_circuit.py: EEA-based Reversible Modular- Inversion Circuit. https://github.com/ZeroWang030221/Space-Efficient-Quantum-Algorithm-for-Elliptic-Curve- Discrete-Logarithms-with-Resource-Estimation/blob/main/eea...

    2026

  25. [33]

    Han Luo, Ziyi Yang, Ziruo Wang, Yuexin Su, and Tongyang Li. 2026. Space-Efficient Quantum Algorithm for Elliptic Curve Discrete Logarithms with Resource Estimation. arXiv:2604.02311 [quant-ph] https://arxiv.org/abs/2604.02311

    2026 arXiv

  26. [34]

    2026.Microsoft Quantum Resource Estimator

    Microsoft. 2026.Microsoft Quantum Resource Estimator. https://learn.microsoft.com/en-us/azure/quantum/intro-to- resource-estimation Accessed: 2026-04-11

    2026

  27. [35]

    Microsoft. 2026. QREv3: Migrating from qsharp.estimate to the Quantum Resource Estimator. https://github.com/ microsoft/qdk/wiki/QREv3. GitHub Wiki, edited by Bill Ticehurst, accessed June 5, 2026

    2026

  28. [36]

    Microsoft Azure Quantum. 2026. T gates and T factories. https://learn.microsoft.com/en-us/azure/quantum/concepts- tfactories. Accessed: 2026-06-01

    2026

  29. [37]

    2026.pyLIQTR

    Kevin Obenland, Justin Elenewski, Kaitlyn Morrell, Benjamin Rempfer, Parker Kuklinski, Rylee Stuart Neumann, Arthur Kurlej, Robert Rood, John Blue, and Joe Belarge. 2026.pyLIQTR. doi:10.5281/zenodo.18154991

    2026 doi

  30. [38]

    Jennifer Paykin, Robert Rand, and Steve Zdancewic. 2017. QWIRE: a core language for quantum circuits.SIGPLAN Not.52, 1 (Jan. 2017), 846–858. doi:10.1145/3093333.3009894

    2017

  31. [39]

    John Preskill. 2018. Quantum Computing in the NISQ era and beyond.Quantum2 (Aug. 2018), 79. doi:10.22331/q- 2018-08-06-79

    2018 doi

  32. [40]

    PsiQuantum Team. 2024. Bartiq. https://github.com/PsiQ/bartiq. Software package

    2024

  33. [41]

    Anthony Ransford, M. S. Allman, Jake Arkinstall, J. P. Campora, Samuel F. Cooper, Robert D. Delaney, Joan M. Dreiling, Brian Estey, Caroline Figgatt, Alex Hall, Ali A. Husain, Akhil Isanaka, Colin J. Kennedy, Nikhil Kotibhaskar, Ivaylo S. Madjarov, Karl Mayer, Alistair R. Miln...

    2026

  34. [42]

    David D.W. Ren. 2026. Pauli Frame Tracking. https://pennylane.ai/compilation/pauli-frame-tracking

    2026

  35. [43]

    Svore, and Kristin Lauter

    Martin Roetteler, Michael Naehrig, Krysta M. Svore, and Kristin Lauter. 2017. Quantum resource estimates for computing elliptic curve discrete logarithms. arXiv:1706.06752 [quant-ph] https://arxiv.org/abs/1706.06752

    2017 arXiv

  36. [44]

    S. N. Saadatmand, Tyler L. Wilson, Mark J. Hodson, Mark Field, Simon J. Devitt, Madhav Krishnan Vijayan, Alan Robert- son, Thinh P. Le, Jannis Ruh, Alexandru Paler, Arshpreet Singh Maan, Ioana Moflic, Athena Caesura, and Josh Y. Mutus

  37. [45]

    Chapuran

    Artur Scherer, Benoît Valiron, Siun-Chuon Mau, Scott Alexander, Eric Berg, and Thomas E. Chapuran. 2017. Concrete resource analysis of the quantum linear-system algorithm used to compute the electromagnetic scattering cross section of a 2D target.Quantum Information Processing...

    2017 doi

  38. [46]

    Peter Selinger. 2004. Towards a quantum programming language.Mathematical. Structures in Comp. Sci.14, 4 (Aug. 2004), 527–586. doi:10.1017/S0960129504004256

    2004 doi

  39. [47]

    P. W. Shor. 1996. Fault-tolerant quantum computation. InProceedings of the 37th Annual Symposium on Foundations of Computer Science (FOCS ’96). IEEE Computer Society, USA, 56

    1996

  40. [48]

    Bolanos, Arabella Schelpe, Tianyi Hao, Philip Seitz, Gian Giacomo Guerreschi, Ángela Elisa Álvarez Pérez, Reinhard Stahn, Jerome Lenssen, Brendan Reid, and Austin Fowler

    Adrien Suau, Yiming Zhang, Purva Thakre, Yilun Zhao, Kabir Dubey, Jose A. Bolanos, Arabella Schelpe, Tianyi Hao, Philip Seitz, Gian Giacomo Guerreschi, Ángela Elisa Álvarez Pérez, Reinhard Stahn, Jerome Lenssen, Brendan Reid, and Austin Fowler. 2026. tqec: A Python package for...

    2026 doi

  41. [50]

    Barbara M. Terhal. 2015. Quantum error correction for quantum memories.Rev. Mod. Phys.87 (Apr 2015), 307–346. Issue 2. doi:10.1103/RevModPhys.87.307

    2015 doi

  42. [51]

    Jean-Pierre Tillich and Gilles Zemor. 2014. Quantum LDPC Codes With Positive Rate and Minimum Distance Proportional to the Square Root of the Blocklength.IEEE Trans. Inf. Theor.60, 2 (Feb. 2014), 1193–1202. doi:10.1109/ TIT.2013.2292061

    2014

  43. [52]

    Wim van Dam, Mariia Mykhailova, and Mathias Soeken. 2023. Using Azure Quantum Resource Estimator for Assessing Performance of Fault Tolerant Quantum Computation. InProceedings of the SC ’23 Workshops of the International Conference on High Performance Computing, Network, Stora...

    2023

  44. [53]

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

    2012

  45. [54]

    Charles Yuan and Michael Carbin. 2022. Tower: data structures in Quantum superposition.Proc. ACM Program. Lang. 6, OOPSLA2, Article 134 (Oct. 2022), 30 pages. doi:10.1145/3563297

    2022 doi

  46. [55]

    Zapata AI. 2023. BenchQ: Resource Estimation for Fault-Tolerant Quantum Computation. https://github.com/ zapatacomputing/benchq. Software package

    2023

  47. [2014]

    InProceedings of the 11th ACM Conference on Computing Frontiers(Cagliari, Italy)(CF ’14)

    ScaffCC: a framework for compilation and analysis of quantum computing programs. InProceedings of the 11th ACM Conference on Computing Frontiers(Cagliari, Italy)(CF ’14). Association for Computing Machinery, New York, NY, USA, Article 1, 10 pages. doi:10.1145/2597917.2597939

  48. [2026]

    arXiv:2406.06015 [quant-ph] https://arxiv.org/abs/2406.06015

    Superconducting qubits in the millions: the potential and limitations of modularity. arXiv:2406.06015 [quant-ph] https://arxiv.org/abs/2406.06015

    arXiv

Pith tools

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