arxiv: 2605.14042 · v1 · submitted 2026-05-13 · 🪐 quant-ph

Recognition: 1 theorem link

· Lean Theorem

C-Phase-Aware Compilation for Efficient Fault-Tolerant Quantum Execution

Dhanvi Bharadwaj , Siddharth Dangwal , Yuewen Hou , Gokul Subramanian Ravi

Authors on Pith no claims yet

Pith reviewed 2026-05-15 05:31 UTC · model grok-4.3

classification 🪐 quant-ph

keywords fault-tolerant quantum computinglattice surgeryquantum compilationC-Phase gatesdynamic schedulingexecution time reductionmicroarchitecture-aware compilation

0 comments

The pith

Compiler exploits C-Phase commutativity to reduce fault-tolerant quantum execution time by up to 59.7 times.

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

The paper develops a compilation method for fault-tolerant quantum computers that accounts for the microarchitecture of lattice surgery implementations. It exploits the fact that C-Phase operations commute to allow multiple gates to run in parallel rather than sequentially. A dynamic scheduler then manages the spatial layout and routing to avoid conflicts. This leads to much better use of hardware resources and far shorter overall run times than conventional approaches. The result matters because quantum advantage requires overcoming large overheads in both space and time.

Core claim

By leveraging the commutativity of C-Phase operations, the compilation approach transforms inherently sequential gate sequences into concurrent multi-target interactions. A dynamic event-driven scheduling strategy models spatial layout and routing constraints to allow operations to overlap while minimizing contention, substantially reducing idle resources in lattice-surgery-based fault-tolerant execution.

What carries the argument

C-Phase commutativity exploitation combined with dynamic event-driven scheduling that integrates algorithmic structure directly with lattice surgery execution.

If this is right

Sequential C-Phase sequences become concurrent multi-target interactions without added dependencies.
Dynamic scheduling overlaps computation and communication while respecting physical layout constraints.
Idle time and routing contention drop sharply compared with coarse slice-based compilation.
Overall wall-clock execution time falls by up to 59.7 times on the same lattice-surgery hardware.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Algorithms previously limited by coherence time may become feasible on near-term fault-tolerant hardware.
Similar commutativity-driven parallelism could be applied to other Clifford operations or different error-correcting codes.
Hardware designs could incorporate native support for event-driven schedulers to capture further gains.

Load-bearing premise

Commutativity of C-Phase operations can be safely exploited in the lattice-surgery setting without introducing logical errors, and the dynamic scheduler models spatial and routing constraints with negligible overhead.

What would settle it

A hardware run or high-fidelity simulation of a compiled circuit that produces logical errors absent in the baseline or that shows measured execution-time savings far below the predicted 59.7 times due to unaccounted contention or errors.

Figures

Figures reproduced from arXiv: 2605.14042 by Dhanvi Bharadwaj, Gokul Subramanian Ravi, Siddharth Dangwal, Yuewen Hou.

**Figure 1.** Figure 1: Current compilers impose artificial serialization and grid idling through rigid time-slices. Qomet exploits algorithm-level C-Phase flexibility and lattice surgery codesign to create multi-target gates, significantly reducing the execution time. across many physical qubits, and computation is performed through space-time-intensive logical operations that suppress physical errors [5, 20, 42]. As a result,… view at source ↗

**Figure 2.** Figure 2: Unlike traditional compilers that decouple program optimization from logical execution (Top), Qomet (Bottom) introduces a Co-Design Engine that fuses algorithmic properties with LS primitives. By reinterpreting sequential gate chains as simultaneous multi-target interactions, Qomet bypasses the artificial constraints of slice-based mapping. The resulting scheduled instructions account for realistic microar… view at source ↗

**Figure 4.** Figure 4: LS instructions for execution Logical CNOT(0,3). (a) ZZ Measurement takes 1 clock cycle (b) Rotation of each ancilla patch, which can be done simultaneously, takes 1 clock cycle, followed by a continuous ZZ measurement, which takes another clock cycle. (c) Final XX measurement takes 1 clock cycle. In total, this CNOT takes 4 clock cycles according to operations specified in [10, 33, 43]. rotations. This in… view at source ↗

**Figure 5.** Figure 5: C-Phase is decomposed since it is not a native gate, enabling execution on standard hardware gate sets. model. 2.4 Prior Compilation Work Logical compilers for surface-code architectures typically address the NP-complete Surface Code Mapping and Routing (SCMR) problem by optimizing qubit placement and ancilla routing [49]. State-of-the-art Clifford+𝑇 compilers predominantly rely on slice-based abstraction… view at source ↗

**Figure 6.** Figure 6: Eliminating false dependencies via CP-aware compilation. (1) Example circuit with two CP gates. (2) Existing approach: despite spatial independence, the compiler enforces serialization. Slices (2a–c) show the CNOT–𝑅𝑧 (𝜃)–CNOT decomposition of CP(0, 1), while (2d–f) show CP(2, 0) under the same constraints. Although operations such as (2d) could overlap with (2a) and (2c), false dependencies force sequenti… view at source ↗

**Figure 7.** Figure 7: Layouts proposed in prior work with the MSstarved density: (a) Compact [35], (b) 1/2-filling [23], (c) 2/3- filling floorplan [23], and (d) Square sparse [35]. 5.3 Performance Metrics The primary metric used to evaluate architectural performance is Speedup. We define Speedup as the ratio of the total execution time, measured in clock cycles, between a baseline compiler and Qomet: Speedup = Total Clock Cy… view at source ↗

**Figure 8.** Figure 8: Execution speedup in the EFT regime across layouts for 100 Qubit QAOA and QFT benchmarks. scheduling policies. Since we observe that DASCOT does not scale to larger instances or certain layouts, we use a greedy baseline in those cases to ensure consistent comparisons. Direct comparisons with DASCOT are provided where applicable (Section 6.3). 6.1 Performance in the EFT Regime We first consider the EFT re… view at source ↗

**Figure 9.** Figure 9: Execution speedup in EFT regimes on the compact layout as logical qubit count increases, evaluated on QAOA and QFT benchmarks. 10 20 50 100 Number of Qubits 0 2 4 6 8 Geo. Mean Speedup QAOA Compact Layout | Magic State Cultivation | ( =6) 10 20 50 100 Number of Qubits 0 20 40 60 Geo. Mean Speedup QFT Compact Layout | Magic State Cultivation | ( =6) QOMET (Pipelined) QOMET (Slice-Based) 1× Baseline [PITH_F… view at source ↗

**Figure 11.** Figure 11: compares Qomet against the greedy compiler baseline across layouts and MS provisioning strategies for 100 logical qubit programs. Qomet’s performance improves with increasing MS availability. In our MS-Abundant setting (where the number of MS patches scales with the logical program qubits) it achieves up to 12.8× speedup for QFT by enabling many T-state transfers to proceed in parallel. In contrast, in… view at source ↗

**Figure 12.** Figure 12: Execution speedup under EFT regimes in the compact layout, under MS-Abundant density, as logical qubit count increases, evaluated on QAOA and QFT benchmarks. 10 20 50 100 Number of Qubits 10 4 10 5 Mean total clock cycles QAOA | Compact Layout | (² = 10) QOMET (Pipelined) DASCOT QOMET (Slice-Based) Greedy Compiler T/O T/O 10 20 50 100 Number of Qubits 10 4 10 5 Mean total clock cycles QAOA | Square Sparse… view at source ↗

**Figure 13.** Figure 13: Mean execution time as qubit count increases for QAOA benchmarks. line scales poorly, as its local, slice-based decisions fail to capture global program structure, leading to increasingly suboptimal execution. The cycle-accurate scheduler provides additional improvements by resolving local contention, but its impact is secondary. This indicates that exploiting structured, multi-target interactions is th… view at source ↗

**Figure 14.** Figure 14: Expected cycles per kept |𝑇 ⟩ shot under MSC. of 5 × 10−4 , the expected cultivation latency is: 𝜏˜𝑐𝑢𝑙𝑡 ≈ 1.9 clock cycles The scheduler treats cultivation as a background operation, overlapping this latency with concurrent Clifford merges to maximize throughput. 16 [PITH_FULL_IMAGE:figures/full_fig_p016_14.png] view at source ↗

read the original abstract

Achieving practical quantum advantage on fault-tolerant quantum computers (FTQC) is fundamentally constrained by the substantial spatial and temporal overheads required to map logical operations onto physical hardware. Existing compilation approaches typically adopt coarse-grained, slice-based abstractions that overlook fine-grained microarchitectural effects, such as routing contention, leading to inefficient resource utilization and limited alignment between algorithm structure and hardware capabilities. This work presents a microarchitecture-aware compilation approach that integrates algorithmic structure directly with lattice surgery (LS) execution. By leveraging the commutativity of C-Phase operations, the method transforms inherently sequential gate sequences into concurrent multi-target interactions, effectively removing artificial dependencies and exposing significant instruction-level parallelism. To enable this, we design a dynamic, event-driven scheduling strategy that accurately models spatial layout and routing constraints, allowing operations to overlap in time while minimizing contention. Through improved coordination of computation and communication, this approach substantially reduces idle resources and achieves up to a 59.7$\times$ reduction in execution time compared to standard baselines.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

The paper claims a nearly 60x runtime cut in lattice-surgery FTQC by turning C-Phase sequences concurrent via commutativity and event-driven scheduling, but the abstract gives no verification that the overlaps preserve logical equivalence.

read the letter

The main takeaway is a compilation method that uses C-Phase commutativity to collapse sequential gates into concurrent multi-target interactions, then feeds those into a dynamic scheduler that tracks spatial layout and routing contention during lattice surgery. The goal is to cut idle time and contention that slice-based compilers leave on the table. That direction makes sense for a real bottleneck in fault-tolerant execution. The paper does a decent job framing the problem in terms of microarchitectural effects rather than staying at the high-level gate count. The scheduler description sounds concrete enough that someone implementing similar flows could try to reproduce the overlap decisions. The 59.7x number is the headline result, and if the baselines are standard slice compilers without fine-grained routing awareness, the improvement is plausible on paper. The soft spot is exactly the one the stress-test flags: nothing in the abstract shows an invariant or small-scale check that concurrent patch merges and splits keep the same stabilizer measurements and correction outcomes. In lattice surgery, overlapping routing paths can create correlated errors or change the effective code distance, and the claim rests on the assumption that the scheduler’s overlap rules avoid those issues. Without seeing the error-model analysis or verification experiments, it is hard to know how much of the speedup survives once those constraints are enforced. This is the kind of work that matters to people building compilers for surface-code hardware. A reader who already works on lattice-surgery scheduling or CNOT/C-Phase optimization would get value from the scheduling heuristics even if the absolute numbers need checking. It is worth sending to peer review so the authors can supply the missing correctness argument and benchmark details; the core idea is specific enough that referees can give targeted feedback rather than a generic desk reject.

Referee Report

3 major / 0 minor

Summary. The paper presents a microarchitecture-aware compilation framework for lattice-surgery-based fault-tolerant quantum computing. It exploits the commutativity of C-Phase operations to convert sequential gate sequences into concurrent multi-target interactions and introduces a dynamic event-driven scheduler that models spatial layout and routing constraints, claiming up to a 59.7× reduction in execution time relative to standard baselines.

Significance. If the commutativity transformations and scheduler decisions provably preserve logical equivalence and code distance without introducing correlated errors, the work could meaningfully reduce temporal overheads in FTQC by exposing instruction-level parallelism and minimizing idle resources. The microarchitecture-aware integration of algorithmic structure with lattice-surgery execution is a relevant direction for practical quantum advantage.

major comments (3)

[Abstract] Abstract: the 59.7× execution-time reduction is presented without baseline definitions, experimental setup details, or any verification that the commutativity-based concurrency transformations preserve logical equivalence under lattice-surgery patch merges, splits, and routing overlaps.
The dynamic scheduler description lacks an explicit invariant or error-model analysis showing that concurrent multi-target C-Phase operations maintain the original stabilizer measurements and correction outcomes; this is load-bearing for the claimed speedup.
No small-scale verification or distance-preserving argument is supplied for the claim that overlapping routing paths introduce negligible overhead while respecting code distance.

Simulated Author's Rebuttal

3 responses · 0 unresolved

We thank the referee for the constructive and detailed feedback. We address each major comment point by point below, indicating where revisions have been made to strengthen the manuscript.

read point-by-point responses

Referee: [Abstract] Abstract: the 59.7× execution-time reduction is presented without baseline definitions, experimental setup details, or any verification that the commutativity-based concurrency transformations preserve logical equivalence under lattice-surgery patch merges, splits, and routing overlaps.

Authors: We agree the abstract is concise and would benefit from added context. In the revised manuscript we have expanded the abstract to explicitly define the baselines as standard sequential lattice-surgery compilation flows that do not exploit C-Phase commutativity, to note that results derive from cycle-accurate microarchitectural simulations on representative quantum algorithms (detailed in Section 4), and to state that logical equivalence is preserved because C-Phase commutativity permits safe reordering while the event-driven scheduler enforces non-interfering patch merges, splits, and routes. A supporting argument appears in the new Section 3.2. revision: yes
Referee: The dynamic scheduler description lacks an explicit invariant or error-model analysis showing that concurrent multi-target C-Phase operations maintain the original stabilizer measurements and correction outcomes; this is load-bearing for the claimed speedup.

Authors: The scheduler already models spatial layout and routing to prevent contention, but we acknowledge that an explicit invariant strengthens the presentation. We have added a dedicated subsection (Section 3.3) that states the scheduler invariant: concurrent multi-target C-Phase operations are permitted only when their routing paths and measurement schedules are disjoint in both space and time, thereby preserving the original stabilizer measurement outcomes and correction statistics. An accompanying error-model analysis shows that the logical operations remain equivalent and that code distance is unchanged because no new correlated error channels are introduced beyond those already accounted for in standard lattice surgery. revision: yes
Referee: No small-scale verification or distance-preserving argument is supplied for the claim that overlapping routing paths introduce negligible overhead while respecting code distance.

Authors: The manuscript argues that the dynamic scheduler eliminates actual overlaps by rescheduling events, so routing overhead remains comparable to sequential execution. We have now inserted an explicit distance-preserving argument in Section 5.1 that shows how the lattice-surgery protocol, when combined with the commutativity-driven concurrency, maintains the original code distance because all patch operations continue to follow the standard merge/split rules. For small-scale verification we have added a new appendix containing distance-3 simulations that confirm negligible additional overhead; these results support but do not replace the larger-scale benchmarks reported in the main text. revision: partial

Circularity Check

0 steps flagged

No circularity detected in derivation chain

full rationale

The paper presents a direct algorithmic compilation technique that exploits C-Phase commutativity and uses an event-driven scheduler for lattice surgery. No equations, fitted parameters, self-citations, or ansatzes are shown that reduce any claimed result to its own inputs by construction. Speedup claims rest on explicit comparisons against external baselines rather than internal redefinitions or self-referential derivations. The method is therefore self-contained against independent benchmarks.

Axiom & Free-Parameter Ledger

0 free parameters · 2 axioms · 0 invented entities

The central claim rests on the domain assumption that C-Phase commutativity holds safely under lattice surgery and that routing contention can be modeled accurately by the scheduler; no free parameters or new entities are introduced in the abstract.

axioms (2)

domain assumption C-Phase operations commute and can be transformed into concurrent multi-target interactions without logical errors
Invoked to remove artificial sequential dependencies in gate sequences.
domain assumption Dynamic event-driven scheduling can accurately capture spatial layout and routing constraints with low overhead
Required for the claimed overlap of operations while minimizing contention.

pith-pipeline@v0.9.0 · 5481 in / 1222 out tokens · 47868 ms · 2026-05-15T05:31:39.698887+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

49 extracted references · 49 canonical work pages · 5 internal anchors

[1]

Yutaro Akahoshi, Kazunori Maruyama, Hirotaka Oshima, Shintaro Sato, and Keisuke Fujii. 2024. Partially Fault-Tolerant Quantum Com- puting Architecture with Error-Corrected Clifford Gates and Space- Time Efficient Analog Rotations.PRX Quantum5 (Mar 2024), 010337. Issue 1. doi:10.1103/PRXQuantum.5.010337

work page doi:10.1103/prxquantum.5.010337 2024
[2]

George S Barron, Fernando A Calderon-Vargas, Junling Long, David P Pappas, and Sophia E Economou. 2020. Microwave-based arbitrary cphase gates for transmon qubits.Physical Review B101, 5 (2020), 054508

work page 2020
[3]

Elisa Bäumer, Vinay Tripathi, Alireza Seif, Daniel Lidar, and Derek S Wang. 2024. Quantum Fourier transform using dynamic circuits. Physical Review Letters133, 15 (2024), 150602

work page 2024
[4]

Beverland, Aleksander Kubica, and Krysta M

Michael E. Beverland, Aleksander Kubica, and Krysta M. Svore. 2021. Cost of Universality: A Comparative Study of the Overhead of State Distillation and Code Switching with Color Codes.PRX Quantum2, 2 (June 2021). doi:10.1103/prxquantum.2.020341

work page doi:10.1103/prxquantum.2.020341 2021
[5]

Assessing requirements to scale to practical quantum advantage

Michael E. Beverland, Prakash Murali, Matthias Troyer, Krysta M. Svore, Torsten Hoefler, Vadym Kliuchnikov, Guang Hao Low, Math- ias Soeken, Aarthi Sundaram, and Alexander Vaschillo. 2022. As- sessing requirements to scale to practical quantum advantage. arXiv:2211.07629 [quant-ph]

work page internal anchor Pith review Pith/arXiv arXiv 2022
[6]

Dhanvi Bharadwaj, Yuewen Hou, Guang-Yi Li, and Gokul Sub- ramanian Ravi. 2026. Scalable Clifford-Based Classical Initial- ization for the Quantum Approximate Optimization Algorithm. arXiv:2602.14327 [quant-ph]https://arxiv.org/abs/2602.14327

work page arXiv 2026
[7]

Sergey Bravyi and Alexei Kitaev. 2005. Universal quantum compu- tation with ideal Clifford gates and noisy ancillas.Physical Review A—Atomic, Molecular, and Optical Physics71, 2 (2005), 022316

work page 2005
[8]

Katherine L Brown, William J Munro, and Vivien M Kendon. 2010. Using quantum computers for quantum simulation.Entropy12, 11 (2010), 2268–2307

work page 2010
[9]

Daan Camps, Roel Van Beeumen, and Chao Yang. 2021. Quantum Fourier Transform Revisited.Numerical Linear Algebra with Applica- tions28, 1 (Jan. 2021), e2331. doi:10.1002/nla.2331arXiv:2003.03011 [math]

work page doi:10.1002/nla.2331arxiv:2003.03011 2021
[10]

Siddharth Dangwal, Suhas Vittal, Lennart Maximilian Seifert, Fred- eric T Chong, and Gokul Subramanian Ravi. 2025. Variational quantum algorithms in the era of early fault tolerance. InProceedings of the 52nd Annual International Symposium on Computer Architecture. 1417–1431

work page 2025
[11]

Edward Farhi, Jeffrey Goldstone, and Sam Gutmann. 2014. A Quantum Approximate Optimization Algorithm. doi:10.48550/arXiv.1411.4028

work page internal anchor Pith review Pith/arXiv arXiv doi:10.48550/arxiv.1411.4028 2014
[12]

& DiVincenzo, D

Austin G. Fowler, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland. 2012. Surface codes: Towards practical large-scale quantum computation.Physical Review A86, 3 (sep 2012). doi:10.1103/physreva. 86.032324

work page doi:10.1103/physreva 2012
[13]

Austin G Fowler, Matteo Mariantoni, John M Martinis, and Andrew N Cleland. 2012. Surface codes: Towards practical large-scale quan- tum computation.Physical Review A—Atomic, Molecular, and Optical Physics86, 3 (2012), 032324

work page 2012
[14]

Craig Gidney. 2024. Inplace access to the surface code y basis.Quantum 8 (2024), 1310

work page 2024
[15]

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

work page internal anchor Pith review Pith/arXiv arXiv 2024
[16]

Adrian Harkness, Shuwen Kan, Chenxu Liu, Meng Wang, John M Martyn, Shifan Xu, Diana Chamaki, Ethan Decker, Ying Mao, Luis F Zuluaga, Tamás Terlaky, Ang Li, and Samuel Stein. 2026. FTCircuit- Bench: A Benchmark Suite for Fault-Tolerant Quantum Compilation and Architecture.arXiv preprint arXiv:2601.03185(2026)

work page arXiv 2026
[17]

Dominic Horsman, Austin G Fowler, Simon Devitt, and Rodney Van Meter. 2012. Surface code quantum computing by lattice surgery. New Journal of Physics14, 12 (Dec. 2012), 123011. doi:10.1088/1367- 2630/14/12/123011

work page doi:10.1088/1367- 2012
[18]

Fei Hua, Yanhao Chen, Yuwei Jin, Chi Zhang, Ari Hayes, Youtao Zhang, and Eddy Z Zhang. 2021. Autobraid: A framework for enabling efficient surface code communication in quantum computing. InMICRO-54: 54th Annual IEEE/ACM International Symposium on Microarchitecture. 925–936

work page 2021
[19]

William J Huggins, Tanuj Khattar, Amanda Xu, Matthew Harrigan, Christopher Kang, Guang Hao Low, Austin Fowler, Nicholas C Rubin, and Ryan Babbush. 2025. The FLuid Allocation of Surface code Qubits (FLASQ) cost model for early fault-tolerant quantum algorithms.arXiv preprint arXiv:2511.08508(2025)

work page arXiv 2025
[20]

Preskill

J. Preskill. 2025. Beyond NISQ: The Megaquop Machine.ACM Trans- actions on Quantum Computing6, 3 (April 2025), 1–7. doi:10.1145/ 3723153

work page 2025
[21]

Yuwei Jin, Jason Luo, Lucent Fong, Yanhao Chen, Ari B Hayes, Chi Zhang, Fei Hua, and Eddy Z Zhang. 2021. A structured method for compilation of qaoa circuits in quantum computing.arXiv preprint arXiv:2112.06143(2021)

work page arXiv 2021
[22]

Youngseok Kim, Andrew Eddins, Sajant Anand, Ken Xuan Wei, Ewout Van Den Berg, Sami Rosenblatt, Hasan Nayfeh, Yantao Wu, Michael Zaletel, Kristan Temme, and Abhinav Kandala. 2023. Evidence for the utility of quantum computing before fault tolerance.Nature618, 7965 (2023), 500–505

work page 2023
[23]

Takumi Kobori, Yasunari Suzuki, Yosuke Ueno, Teruo Tanimoto, Synge Todo, and Yuuki Tokunaga. 2025. Lsqca: Resource-efficient load/store architecture for limited-scale fault-tolerant quantum computing. In 2025 IEEE International Symposium on High Performance Computer Architecture (HPCA). IEEE, 304–320

work page 2025
[24]

David Kremer, Victor Villar, Hanhee Paik, Ivan Duran, Ismael Faro, and Juan Cruz-Benito. 2024. Practical and efficient quantum circuit synthesis and transpiling with reinforcement learning.arXiv preprint arXiv:2405.13196(2024)

work page arXiv 2024
[25]

Lingling Lao and Ben Criger. 2022. Magic state injection on the rotated surface code. InProceedings of the 19th ACM International Conference on Computing Frontiers. 113–120

work page 2022
[26]

Lingling Lao and Ben Criger. 2022. Magic state injection on the rotated surface code. InProceedings of the 19th ACM International Conference on Computing Frontiers(Turin, Italy)(CF ’22). Association for Computing Machinery, New York, NY, USA, 113–120. doi:10.1145/ 3528416.3530237

work page arXiv 2022
[27]

Tyler LeBlond and Ryan S Bennink. 2025. Quantum resource compar- ison for two leading surface code lattice surgery approaches.arXiv preprint arXiv:2506.08182(2025)

work page arXiv 2025
[28]

Gushu Li, Yufei Ding, and Yuan Xie. 2019. Tackling the qubit map- ping problem for NISQ-era quantum devices. InProceedings of the twenty-fourth international conference on architectural support for pro- gramming languages and operating systems. 1001–1014

work page 2019
[29]

2013.Quantum error correction

Daniel A Lidar and Todd A Brun. 2013.Quantum error correction. Cambridge university press. 13 Dhanvi Bharadwaj, Siddharth Dangwal, Yuewen Hou, and Gokul Subramanian Ravi

work page 2013
[30]

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

work page 2019
[31]

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-128arXiv:1808.02892 [quant-ph]

work page internal anchor Pith review Pith/arXiv arXiv 2019
[32]

Daniel Litinski. 2019. Magic State Distillation: Not as Costly as You Think.Quantum3 (Dec. 2019), 205. doi:10.22331/q-2019-12-02-205 arXiv:1905.06903 [quant-ph]

work page doi:10.22331/q-2019-12-02-205 2019
[33]

Daniel Litinski. 2019. Magic state distillation: Not as costly as you think.Quantum3 (2019), 205

work page 2019
[34]

Calado, and Lieven M.K

Tristan Meunier, Victor E. Calado, and Lieven M.K. Vandersypen. 2010. Efficient controlled-phase gate for single-spin qubits in quantum dots. Physical Review B83 (2010), 121403.https://api.semanticscholar.org/ CorpusID:55204456

work page 2010
[35]

Abtin Molavi, Amanda Xu, Swamit Tannu, and Aws Albarghouthi

work page
[36]

ACM Program

Dependency-Aware Compilation for Surface Code Quantum Architectures.Proc. ACM Program. Lang.9, OOPSLA1, Article 82 (April 2025), 28 pages. doi:10.1145/3720416

work page doi:10.1145/3720416 2025
[37]

National Energy Research Scientific Computing Center (NERSC). 2025. Perlmutter System.https://www.nersc.gov/what-we-do/computing- for-science/perlmutter. Accessed: 2025-11-17

work page 2025
[38]

John Preskill. 2018. Quantum Computing in the NISQ era and beyond. Quantum2 (2018), 79

work page 2018
[39]

Joschka Roffe. 2019. Quantum error correction: an introductory guide. Contemporary Physics60, 3 (Jul 2019), 226–245. doi:10.1080/00107514. 2019.1667078

work page doi:10.1080/00107514 2019
[40]

Neil J Ross and Peter Selinger. 2014. Optimal ancilla-free Clifford+ T approximation of z-rotations.arXiv preprint arXiv:1403.2975(2014)

work page internal anchor Pith review Pith/arXiv arXiv 2014
[41]

Sayam Sethi and Jonathan Mark Baker. 2025. RESCQ: Realtime Scheduling for Continuous Angle Quantum Error Correction Ar- chitectures. InProceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2(Rotterdam, Netherlands)(ASPLOS ’25). Associ- ation for Computing Machinery, New York, ...

work page doi:10.1145/3676641.3716018 2025
[43]

Peter W Shor. 1996. Fault-tolerant quantum computation. InPro- ceedings of 37th conference on foundations of computer science. IEEE, 56–65

work page 1996
[44]

Daniel Bochen Tan, Murphy Yuezhen Niu, and Craig Gidney. 2024. A SAT Scalpel for Lattice Surgery: Representation and Synthesis of Subroutines for Surface-Code Fault-Tolerant Quantum Computing. arXiv preprint arXiv:2404.18369(2024)

work page arXiv 2024
[45]

Riki Toshio, Yutaro Akahoshi, Jun Fujisaki, Hirotaka Oshima, Shintaro Sato, and Keisuke Fujii. 2025. Practical quantum advantage on partially fault-tolerant quantum computer.Physical Review X15, 2 (2025), 021057

work page 2025
[46]

Riki Toshio, Shota Kanasugi, Jun Fujisaki, Hirotaka Oshima, Shintaro Sato, and Keisuke Fujii. 2026. STAR-Magic Mutation: Even More Efficient Analog Rotation Gates for Early Fault-Tolerant Quantum Computer.arXiv preprint arXiv:2603.22891(2026)

work page arXiv 2026
[47]

Yosuke Ueno, Masaaki Kondo, Masamitsu Tanaka, Yasunari Suzuki, and Yutaka Tabuchi. 2022. QULATIS: A Quantum Error Correction Methodology toward Lattice Surgery. In2022 IEEE International Sym- posium on High-Performance Computer Architecture (HPCA). 274–287. doi:10.1109/HPCA53966.2022.00028

work page doi:10.1109/hpca53966.2022.00028 2022
[48]

George Watkins, Hoang Minh Nguyen, Keelan Watkins, Steven Pearce, Hoi-Kwan Lau, and Alexandru Paler. 2024. A high performance com- piler for very large scale surface code computations.Quantum8 (2024), 1354

work page 2024
[49]

Willers Yang, Jason Chadwick, Mariesa H Teo, Joshua Viszlai, and Fred Chong. 2026. RASCqL: Reaction-time-limited Architecture for Space- time-efficient Complex qLDPC Logic.arXiv preprint arXiv:2602.14273 (2026)

work page arXiv 2026
[50]

Mingzheng Zhu, Hao Fu, Jun Wu, Chi Zhang, Wei Xie, and Xiang- Yang Li. 2024. Ecmas: Efficient Circuit Mapping and Scheduling for Surface Code. In2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). 158–169. doi:10.1109/CGO57630. 2024.10444874 A Routing and Scheduling Mechanisms A.1𝑅 𝑧 (𝜃) Implementation: 𝑇 via Magic State Patch...

work page doi:10.1109/cgo57630 2024