Pith. sign in

REVIEW 4 major objections 5 minor 2 cited by

Trace-Based Reconstruction of Quantum Circuit Dataflow in Surface Codes

T0 review · 4 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

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

Pith's one-line read The paper claims that one free/busy bit per surface-code patch per timestep suffices to reconstruct a quantum circuit's two-qubit gate dependency graph, and that TraceQ does so from a single trace with high accuracy.

desk verdict A genuinely new problem and a plausible framework, but the paper's central claim — that L1 traces recover the two-qubit dependency DAG — is never actually validated against ground truth. read the letter →

arxiv 2508.14533 v1 pith:2DGHGSKD submitted 2025-08-20 quant-ph cs.ARcs.ETcs.SE

Theodoros Trochatos , Christopher Kang , Andrew Wang , Frederic T. Chong , Jakub Szefer This is my paper
classification quant-phcs.ARcs.ETcs.SE
keywords accesstraceslatticesurgerysurfacecodesquantumcircuitdataflowreconstructiondependencyDAGsubgraphisomorphismfault-tolerantcomputingside-channelanalysis
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 the binary free/busy history of surface-code patches during lattice surgery—one bit per qubit patch per timestep, with no labels, roles, or routing metadata—is enough to reconstruct the logical dataflow of a quantum program, specifically the dependency DAG of its two-qubit gates. The authors build TraceQ, a pipeline that recovers qubit endpoints and routing paths from these minimal traces using three heuristics and a backtracking DFS solver, then reconstructs the gate DAG and applies exact subgraph matching to detect known subroutines embedded in a larger program. Evaluated on 600 randomized synthetic FTQC circuits across three layouts, the pipeline identifies embedded subroutines with high recall (74–95% depending on layout), zero false positives, from a single trace per execution, fully offline. If the claim holds, the same activity channel already available to controllers—or to a side-channel observer—carries the full structure of a fault-tolerant program.

What carries the argument

Access traces: a time-indexed sequence of d×d binary matrices in which a 1 marks a surface-code patch participating in a lattice-surgery operation and a 0 marks an idle patch. The framework's engine is a heuristic chain that converts these bits into a path-level (L3) description — adjacent-edge activation, logical-qubit endpoint identification via low-degree and temporal-co-occurrence cues, and a DFS with backtracking that enumerates all non-overlapping paths through active patches — followed by DAG construction and exact subgraph isomorphism (the VF3 algorithm) for subroutine fingerprinting.

What would settle it

Feed TraceQ an L1 trace generated by a real lattice-surgery compiler that interleaves T-gate magic-state routing and multi-qubit measurements with CNOT paths; if the recovered qubit-endpoint parity is odd for a significant fraction of timesteps, or if subroutine recall falls below the reported rates, the clean-path model is wrong.

Watch

Extended reading notes

Core claim

The central claim, stated in the paper's introduction as a postulate, is that the space-time patterns of activity produced by lattice surgery encode all information needed to recover quantum circuit dataflow, circuit operation, and available parallelism on the target computer. TraceQ demonstrates this for the L1 (binary free/busy) trace level: it recovers the ordered dependency DAG of two-qubit gates, and then uses exact subgraph isomorphism to locate subroutine DAGs (adders, Quantum Fourier Transforms, Trotter steps) inside the reconstructed program DAG. The reported result is that 95% of subroutine instances are recovered on the Compact layout, 88% on Intermediate, and 74% on the more ambi

Load-bearing premise

The whole reconstruction rests on the assumption that every active patch in a trace belongs to one clean, unbroken routing path between two qubits, with no overlap and no other activity such as magic-state preparation, measurement, or decoding mixed in; real device traces may not honor that.

Editorial extensions

If this is right

  • A party that can observe patch-level activity—such as the control stack during profiling, or an attacker with physical access to controller signals—can recover the two-qubit gate dependency graph of a fault-tolerant program without any annotations about logical qubit roles or routing.
  • The recovered DAG identifies known subroutines (adders, QFTs, Trotter steps) with high recall and zero false positives, so the same framework can serve as a runtime profiler, a program-integrity checker, or a side-channel reconnaissance tool.
  • The density of the layout directly trades off against information leakage: sparse layouts that maximize parallelism produce more ambiguous traces and take longer to resolve, while compact layouts are resolved in under a second and leak program structure most readily.
  • Because only a single binary trace per execution is required and the analysis is offline, the method is compatible with long-running FTQC workloads and does not require instrumenting the quantum computer beyond the free/busy records a controller would already keep.

Reading between the lines

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

  • The strongest unstated consequence is a security one: if a remote adversary can obtain controller-level activity records (e.g., through a shared cloud stack or a power/EM side channel on the control hardware), TraceQ-style reconstruction turns that physical leakage into a high-level fingerprint of the computational workload, raising the stakes for protecting these records.
  • The trace model deliberately ignores T-gate/magic-state traffic and measurement overhead; injecting those into the trace-generation stage is a natural stress test that would show how much of the reported accuracy survives realistic FTQC activity.
  • The zero-false-positive finding under exact matching suggests a precision-recall trade that the authors did not explore: a probabilistic matcher could raise recall on the highly ambiguous Square Sparse layout at the cost of some spurious detections.
  • The relation between ambiguity and layout hints that architectural designers could deliberately shape traces—e.g., by inserting routing style changes—to make programs harder to fingerprint, an anti-profiling design direction that the paper does not address.
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 / 5 minor

Summary. The paper introduces access traces: binary, time-indexed matrices of free/busy status of surface-code patches during lattice-surgery execution. It claims that from the minimal Level-1 (L1) traces, the TraceQ framework can recover the dependency DAG of two-qubit gates (Q1) and identify embedded subroutines within a larger program (Q2), potentially whole programs. Traces are generated by a custom A*-based router with a greedy scheduling policy; TraceQ applies heuristics to recover qubit roles and paths, uses DFS with backtracking to enumerate valid path configurations for ambiguous trace entries, constructs an 'augmented, ambiguity-aware program DAG', and performs subroutine detection via exact subgraph isomorphism (VF3). The evaluation covers 600 synthetic circuits across three layouts and reports no false-positive subroutine matches, with 74%/95%/88% subroutine recovery for the Sparse/Compact/Intermediate layouts, respectively.

Significance. If the reconstruction claims held, this would be a valuable contribution to profiling and side-channel analysis of fault-tolerant quantum computers: a bare free/busy trace would expose logical connectivity and subroutine identity. The paper provides a clearly specified trace abstraction, a substantial synthetic evaluation, and an end-to-end pipeline; the use of exact subgraph matching is a strength. However, the evaluation does not directly measure fidelity of the reconstructed dependency DAG, and the whole-program claim is not tested. The framework is plausible and internally coherent, but the headline accuracy numbers are not yet backed by an appropriate ground-truth comparison.

major comments (4)
  1. [§IV-D, §V-D, Figs. 13 and 15] Q1, the central claim of recovering logical dependencies, is never directly scored. The reconstructed object is an 'augmented, ambiguity-aware program DAG' that inserts a separate gate node for every valid DFS path configuration. Fig. 13 reports only whether DFS completed without an odd-endpoint exception, and the text concedes that even-endpoint runs can still have missed endpoints. No precision/recall or graph-distance metric against the ground-truth two-qubit DAG is reported. Consequently, the 74–95% subroutine recovery in Fig. 15 is measured against a superset graph containing all alternative paths; a match against such a superset is compatible with many spurious gates and incorrect dependencies. Please add a direct fidelity metric for Q1 (e.g., edge/node precision-recall on reconstructed vs. ground-truth DAG, or graph edit distance) and report how often ambiguity resolution produced
  2. [Abstract, §V] The abstract claims that minimal access traces 'can be used to recover subroutines or even whole quantum programs with very high accuracy.' However, no whole-program identification experiment is reported; all presented detections are subroutine instances embedded in synthetic mixes (Fig. 15). Either add a whole-program identification experiment or revise the claim to subroutine identification only, with the caveat that even subroutine recovery is evaluated only against the augmented superset DAG.
  3. [§IV-A, §IV-B, §VII] The evaluation is closed-loop with respect to the trace model. The L1 trace generator uses the authors' custom A* router with an as-many-as-possible scheduler, and the recovery heuristics in §IV-B essentially invert this clean-path model: paths are contiguous, avoid inactive qubit positions, and do not overlap. Real FTQC executions also carry magic-state traffic, T-gate lattice surgery, measurement, and decoding overhead, and real compilers need not route as the authors' greedy router does. The paper defers T gates to future work in §VII. This is a legitimate limitation, but the abstract's phrasing overstates external validity. Please evaluate on traces from an independent compiler/router or from a full lattice-surgery simulator, or explicitly restrict the claims to the clean-path model.
  4. [§IV-B2, §V-D, Fig. 13] Endpoint identification is a second load-bearing gap. Heuristic 2 is guaranteed only not to mislabel logical qubits, not to find all of them; the only reported detection of missed endpoints is parity of the recovered endpoint count. The text in §V-D states that even-parity runs can still have missed endpoints and identifies those missed endpoints as the cause of later failed subgraph matches. The paper never quantifies the rate of missed endpoints across all trace entries. Please report endpoint recall with respect to ground-truth active endpoints, or at least the number of missed endpoints in both successful and unsuccessful runs, so that the Fig. 13 'success rate' can be interpreted.
minor comments (5)
  1. [Fig. 13] The label 'success rate' is misleading; the metric is 'fraction of runs that completed without an odd-endpoint exception.' Rename it to avoid implying DAG or layout recovery success.
  2. [§III-B] Formatting issues: 'Tyields' should be 'T yields', 'Mt[r,c] = 1indicates' needs a space, and the set notation '0, 1d×d' should be typeset as {0,1}^{d×d}.
  3. [Abstract] Typo: 'noise andimperfections inherent' should be 'noise and imperfections inherent'.
  4. [Fig. 5, Fig. 6, Fig. 7] The figures rely on light-green coloring to distinguish actual busy edges from heuristic annotations. Please add hatching, line styles, or a clear legend for print/accessibility.
  5. [Table I, Fig. 15] Subroutine names such as 't npe' appear with inconsistent spacing; align them with the labels used in Fig. 15.

Circularity Check

1 steps flagged · score 4.0 of 10

Subroutine-detection claim partially reduces by construction: the augmented DAG is built to contain every valid routing, so the true subroutine is present whenever endpoint recovery succeeds.

  1. self definitional [Section IV-D (DAG Reconstruction), evaluated in Section V-D (Figs. 13 and 15)]
    "For ambiguous steps, we insert a separate gate node for each valid configuration and link all dependencies accordingly. Per-qubit histories are maintained to determine lookahead constraints when inserting edges, ensuring correctness in gate ordering. The result is an augmented, ambiguity-aware program DAG."

    The trace generator (IV-A) produces each gate's activity by routing paths that 'avoid physical overlaps and inactive qubit positions,' so the true routing is always a valid solution under the DFS validity rule of IV-C (paths 'utilize all active patches' and do not cross). IV-D then inserts a gate node for every valid configuration, so the true gates are contained in the 'reconstructed' DAG by construction whenever endpoints are recovered. Consequently, the exact-subgraph subroutine detection (IV-D, Fig. 15) is guaranteed by the construction whenever the Fig. 13 DFS run completes; the 74-95% detection rates re-express the even-endpoint-parity success metric rather than independently validating DAG recovery fidelity. The paper concedes Fig. 13 'does not reflect the success rate of fully reco

full rationale

The paper does not rely on load-bearing self-citation, fitted parameters, or imported uniqueness theorems: the trace-to-DAG inference is a genuine inverse problem (binary free/busy matrices to a dependency DAG), the subroutine circuits come from external pyLIQTR, layouts come from the literature, and the heuristics can and do fail (missed endpoints, timeouts). The central circularity concern is confined to the evaluation chain: because the generator's routing model (IV-A) and the DFS validity criteria (IV-C) are the same model, and IV-D deliberately inserts all valid configurations into an 'augmented' DAG, the true subroutine is guaranteed to be present in the reconstructed graph whenever the DFS finds the endpoints. The Fig. 15 detection rates therefore largely restate the Fig. 13 endpoint-parity success rate, not a validation of accurate dataflow recovery; this is a partial, construction-driven circularity in the headline accuracy claim. The paper itself flags the Fig. 13 metric's blindness to missed endpoints and the augmentation of the DAG, which supports weighing this as a real but partial issue (score 4) rather than vacuous self-reference. Separate limitations—no whole-program identification experiment, closed-loop evaluation against the authors' own clean-path router, and unmodeled real-world traffic (magic states, T gates, decoder overhead)—are correctness/external-validity concerns rather than circularity, and are noted here rather than in the score.

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

The paper fits no parameters to data, so the free-parameter list is empty. The axioms are the domain assumptions connecting real lattice-surgery execution to the simulated trace model, plus the standard algorithmic correctness of VF3 and the representativeness of the synthetic subroutine library. The only invented entity is the access-trace abstraction itself, a definitional object with no independent falsifiable handle.

assumptions (5)
  • domain assumption Gate-based FTQC can be compiled to lattice surgery with constant overhead, so two-qubit gates are realized by patch merging and splitting (Fowler et al., ref [12]).
    Invoked in Section II-B to justify that patch activity is the right object to observe; the paper does not model lower-level lattice surgery primitives or magic-state distillation traffic.
  • domain assumption At each timestep every patch is cleanly observable as active or idle, and routing paths avoid physical overlaps and inactive qubit positions (Section IV-A).
    This clean-path trace model is the input to all three recovery heuristics; real controllers also carry error-correction, measurement, and T-gate traffic that could contaminate the binary signal.
  • domain assumption The dependency structure of interest is fully described by two-qubit gates; T gates and single-qubit gates can be excluded (Section VII).
    The authors state this explicitly and argue two-qubit gates give 'important insights' without overhead; the claim about 'whole quantum programs' inherits this restriction.
  • standard math VF3 exact subgraph isomorphism is correct and complete as described in Carletti et al. (ref [5]).
    Used in Section IV-D for subroutine detection; the paper relies on the published algorithm rather than proving its correctness.
  • domain assumption pyLIQTR-generated adder, QFT, product, and Trotterization circuits are representative of subroutine structures in real FTQC programs (Section V-A).
    The benchmark set is synthetic by construction; representativeness for real workloads such as Shor or chemistry is asserted, not demonstrated.
invented entities (1)
  • Access traces (Level-1/2/3)
    purpose: Formal abstraction of per-patch space-time activity during lattice surgery; the paper's central observable and the input to TraceQ.
    A definitional modeling construct, not a physical entity. It has no falsifiable handle outside the paper; its utility is judged by whether real FTQC controllers can emit such traces and whether the recovery rates transfer.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Trace-Based Reconstruction of Quantum Circuit Dataflow in Surface Codes." pith.science (2026). https://pith.science/paper/2DGHGSKD

@misc{pith2026250814533,
  author       = {Pith},
  title        = {Pith review of: Trace-Based Reconstruction of Quantum Circuit Dataflow in Surface Codes},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2DGHGSKD}},
  note         = {Machine review of arXiv:2508.14533}
}
read the original abstract

Practical applications of quantum computing depend on fault-tolerant devices that employ error correction. A promising quantum error-correcting code for large-scale quantum computing is the surface code. For this code, Fault-Tolerant Quantum Computing (FTQC) can be performed via lattice surgery, i.e. merging and splitting of encoded qubit patches on a 2D grid. Lattice surgery operations result in space-time patterns of activity that are defined in this work as access traces. This work demonstrates that the access traces reveal when, where, and how logical qubits interact. Leveraging this formulation, this work further introduces TraceQ, a trace-based reconstruction framework that is able to reconstruct the quantum circuit dataflow just by observing the patch activity at each trace entry. The framework is supported by heuristics for handling inherent ambiguity in the traces, and demonstrates its effectiveness on a range of synthetic fault-tolerant quantum benchmarks. The access traces can have applications in a wide range of scenarios, enabling analysis and profiling of execution of quantum programs and the hardware they run on. As one example use of TraceQ, this work investigates whether such traces can act as a side channel through which an observer can recover the circuit's structure and identify known subroutines in a larger program or even whole programs. The findings show that indeed the minimal access traces can be used to recover subroutines or even whole quantum programs with very high accuracy. Only a single trace per program execution is needed and the processing can be done fully offline. Along with the custom heuristics, advanced subgraph matching algorithms used in this work enable a high rate of locating the subroutines while executing in minimal time.

Discussion (0). Sign in to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. Design automation and space-time reduction for surface-code logical operations using a SAT-based EDA kernel compatible with general encodings

    quant-ph 2026-04 unverdicted novelty 7.0 of 10

    KOVAL-Q uses SAT solving to optimize and verify surface-code logical operations with general encodings, finding d-cycle CNOTs and 2d-cycle rotations that reduce FTQC application runtime by about 10 percent.

  2. O3LS: Optimizing Lattice Surgery via Automatic Layout Searching and Loose Scheduling

    quant-ph 2026-04 unverdicted novelty 6.0 of 10

    O3LS reduces space overhead by up to 46.7% and time overhead by up to 36% in lattice surgery while suppressing logical error rates by up to an order of magnitude compared with prior layout and scheduling approaches.

Reference graph

Works this paper leans on

33 extracted references · 24 canonical work pages · cited by 2 Pith papers

  1. [1]

    Suppressing quantum errors by scaling a surface code logical qubit,

    “Suppressing quantum errors by scaling a surface code logical qubit,” Nature, vol. 614, no. 7949, pp. 676–681, 2023

    work page 2023

  2. [2]

    A real-time, scalable, fast and resource-efficient decoder for a quantum computer,

    B. Barber, K. M. Barnes, T. Bialas, O. Bu ˘gdaycı, E. T. Campbell, N. I. Gillespie, K. Johar, R. Rajan, A. W. Richardson, L. Skoric et al., “A real-time, scalable, fast and resource-efficient decoder for a quantum computer,” Nature Electronics, vol. 8, no. 1, pp. 84–91, 2025

    work page 2025

  3. [3]

    Quantum error correction via codes over gf (4),

    A. R. Calderbank, E. M. Rains, P. M. Shor, and N. J. Sloane, “Quantum error correction via codes over gf (4),” IEEE Trans- actions on Information Theory , vol. 44, no. 4, pp. 1369–1387, 1998

    work page 1998

  4. [4]

    Vf-gpu: Exploiting parallel gpu architectures to solve subgraph isomorphism,

    V . Carletti, P. Foggia, F. Rosa, and M. Vento, “Vf-gpu: Exploiting parallel gpu architectures to¬†solve subgraph isomorphism,” in Graph-Based Representations in Pattern Recognition , L. Brun, V . Carletti, S. Bougleux, and B. Ga ¨uz`ere, Eds. Cham: Springer Nature Switzerland, 2025, pp. 113–123

    work page 2025

  5. [5]

    Introducing vf3: A new algorithm for subgraph isomorphism,

    V . Carletti, P. Foggia, A. Saggese, and M. Vento, “Introducing vf3: A new algorithm for subgraph isomorphism,” in Interna- tional Workshop on Graph-Based Representations in Pattern Recognition. Springer, 2017, pp. 128–139

    work page 2017

  6. [6]

    Universal quantum com- puting with twist-free and temporally encoded lattice surgery,

    C. Chamberland and E. T. Campbell, “Universal quantum com- puting with twist-free and temporally encoded lattice surgery,” PRX Quantum, vol. 3, no. 1, p. 010331, 2022

    work page 2022

  7. [7]

    Cryo-cmos for quan- tum computing,

    E. Charbon, F. Sebastiano, A. Vladimirescu, H. Homulle, S. Visser, L. Song, and R. M. Incandela, “Cryo-cmos for quan- tum computing,” in 2016 IEEE International Electron Devices Meeting (IEDM). IEEE, 2016, pp. 13–5

    work page 2016

  8. [8]

    Open quantum assembly language,

    A. W. Cross, L. S. Bishop, J. A. Smolin, and J. M. Gambetta, “Open quantum assembly language,” 2017. [Online]. Available: https://arxiv.org/abs/1707.03429

    arXiv 2017

Show all 33 references
  1. [9]

    Topological quantum memory,

    E. Dennis, A. Kitaev, A. Landahl, and J. Preskill, “Topological quantum memory,” Journal of Mathematical Physics , vol. 43, no. 9, pp. 4452–4505, 2002

    2002

  2. [10]

    Quantum circuit recon- struction from power side-channel attacks on quantum computer controllers,

    F. Erata, C. Xu, R. Piskac, and J. Szefer, “Quantum circuit recon- struction from power side-channel attacks on quantum computer controllers,” IACR Transactions on Cryptographic Hardware and Embedded Systems, vol. 2024, no. 2, pp. 735–768, 2024

    2024

  3. [11]

    Low overhead quantum compu- tation using lattice surgery,

    A. G. Fowler and C. Gidney, “Low overhead quantum compu- tation using lattice surgery,” arXiv preprint arXiv:1808.06709 , 2018

    2018 arXiv

  4. [12]

    Surface codes: Towards practical large-scale quantum com- putation,

    A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, “Surface codes: Towards practical large-scale quantum com- putation,” Physical Review A—Atomic, Molecular, and Optical Physics, vol. 86, no. 3, p. 032324, 2012

    2012

  5. [13]

    Gottesman, Stabilizer codes and quantum error correction

    D. Gottesman, Stabilizer codes and quantum error correction . California Institute of Technology, 1997

    1997

  6. [14]

    Exploring network structure, dynamics, and function using networkx

    A. Hagberg, P. J. Swart, and D. A. Schult, “Exploring network structure, dynamics, and function using networkx.” Los Alamos National Laboratory (LANL), 12 2007. [Online]. Available: https://www.osti.gov/biblio/960616

    2007

  7. [15]

    Surface code quantum computing by lattice surgery,

    D. Horsman, A. G. Fowler, S. Devitt, and R. Van Meter, “Surface code quantum computing by lattice surgery,” New Journal of Physics, vol. 14, no. 12, p. 123011, 2012

    2012

  8. [16]

    Decoding algorithms for surface codes,

    A. d. iOlius, P. Fuentes, R. Or ´us, P. M. Crespo, and J. E. Mar- tinez, “Decoding algorithms for surface codes,” arXiv preprint arXiv:2307.14989, 2023

    2023 arXiv

  9. [17]

    Quantum computing with qiskit,

    A. Javadi-Abhari, M. Treinish, K. Krsulich, C. J. Wood, J. Lishman, J. Gacon, S. Martiel, P. D. Nation, L. S. Bishop, A. W. Cross, B. R. Johnson, and J. M. Gambetta, “Quantum computing with qiskit,” 2024. [Online]. Available: https://arxiv.org/abs/2405.08810

    2024 arXiv

  10. [18]

    Quantum simulation with sum-of-squares spectral am- plification,

    R. King, G. H. Low, R. Babbush, R. D. Somma, and N. C. Rubin, “Quantum simulation with sum-of-squares spectral am- plification,” arXiv preprint arXiv:2505.01528 , 2025

    2025 arXiv

  11. [19]

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

    A. Li, S. Stein, S. Krishnamoorthy, and J. Ang, “Qasmbench: A low-level quantum benchmark suite for nisq evaluation and simulation,” ACM Transactions on Quantum Computing , vol. 4, no. 2, pp. 1–26, 2023

    2023

  12. [20]

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

    D. Litinski, “A game of surface codes: Large-scale quantum computing with lattice surgery,” Quantum, vol. 3, p. 128, Mar

  13. [21]

    Active volume: An architecture for efficient fault-tolerant quantum computers with limited non- local connections,

    D. Litinski and N. Nickerson, “Active volume: An architecture for efficient fault-tolerant quantum computers with limited non- local connections,” arXiv preprint arXiv:2211.15465 , 2022

    2022 arXiv

  14. [22]

    Dependency- aware compilation for surface code quantum architectures,

    A. Molavi, A. Xu, S. Tannu, and A. Albarghouthi, “Dependency- aware compilation for surface code quantum architectures,” Proc. ACM Program. Lang. , vol. 9, no. OOPSLA1, Apr. 2025. [Online]. Available: https://doi.org/10.1145/3720416

    2025 doi

  15. [23]

    A race-track trapped-ion quantum processor,

    S. A. Moses, C. H. Baldwin, M. S. Allman, R. Ancona, L. Ascar- runz, C. Barnes, J. Bartolotta, B. Bjork, P. Blanchard, M. Bohn et al. , “A race-track trapped-ion quantum processor,” Physical Review X, vol. 13, no. 4, p. 041052, 2023

    2023

  16. [24]

    Meet willow, our state-of-the-art quantum chip,

    H. Neven, “Meet willow, our state-of-the-art quantum chip,” Dec 2024. [Online]. Available: https://blog.google/technology/ research/google-willow-quantum-chip/

    2024

  17. [25]

    pyliqtr,

    K. Obenland, J. Elenewski, K. Morrell, B. Rempfer, P. Kuklinski, R. S. Neumann, A. Kurlej, R. Rood, J. Blue, and J. Belarge, “pyliqtr,” May 2025. [Online]. Available: https://doi.org/10.5281/ zenodo.15492111

    2025

  18. [26]

    Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer,

    P. W. Shor, “Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer,” SIAM review, vol. 41, no. 2, pp. 303–332, 1999. 12

    1999

  19. [27]

    A sat scalpel for lattice surgery: Representation and synthesis of subroutines for surface-code fault-tolerant quantum computing,

    D. B. Tan, M. Y . Niu, and C. Gidney, “A sat scalpel for lattice surgery: Representation and synthesis of subroutines for surface-code fault-tolerant quantum computing,” in 2024 ACM/IEEE 51st Annual International Symposium on Computer Architecture (ISCA) . IEEE, Jun. 2024, p. ...

    2024

  20. [28]

    Supermarq: A scalable quantum benchmark suite,

    T. Tomesh, P. Gokhale, V . Omole, G. S. Ravi, K. N. Smith, J. Viszlai, X.-C. Wu, N. Hardavellas, M. R. Martonosi, and F. T. Chong, “Supermarq: A scalable quantum benchmark suite,” in 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA). IEEE, 2022...

    2022

  21. [29]

    Quantum computing enhanced computational catalysis,

    V . von Burg, G. H. Low, T. H ¨aner, D. S. Steiger, M. Reiher, M. Roetteler, and M. Troyer, “Quantum computing enhanced computational catalysis,” Physical Review Research, vol. 3, no. 3, p. 033055, 2021

    2021

  22. [30]

    A high performance compiler for very large scale surface code computations,

    G. Watkins, H. M. Nguyen, K. Watkins, S. Pearce, H.-K. Lau, and A. Paler, “A high performance compiler for very large scale surface code computations,” Quantum, vol. 8, p. 1354, 2024

    2024

  23. [31]

    A classical architecture for digital quantum computers,

    F. Zhang, X. Zhu, R. Chao, C. Huang, L. Kong, G. Chen, D. Ding, H. Feng, Y . Gao, X. Ni, L. Qiu, Z. Wei, Y . Yang, Y . Zhao, Y . Shi, W. Zhang, P. Zhou, and J. Chen, “A classical architecture for digital quantum computers,” 2023. [Online]. Available: https://arxiv.org/abs/2305.14304

    2023 arXiv

  24. [32]

    Fault-tolerant quantum algorithms for quantum molecular systems: A survey,

    Y . Zhang, X. Zhang, J. Sun, H. Lin, Y . Huang, D. Lv, and X. Yuan, “Fault-tolerant quantum algorithms for quantum molecular systems: A survey,” 2025. [Online]. Available: https://arxiv.org/abs/2502.02139 13

    2025

  25. [2019]

    Available: http://dx.doi.org/10.22331/q-2019-03- 05-128

    [Online]. Available: http://dx.doi.org/10.22331/q-2019-03- 05-128

    2019 doi

Pith tools

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