Pith. sign in

REVIEW 3 major objections 6 minor 1 cited by

This paper claims that compiling error-corrected silicon spin qubit circuits can be reduced to a graph routing problem, and that two algorithm families—shortest-path and cyclic-rotation—solve it with complementary trade-offs.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-02 08:00 UTC pith:22X7CIPK

load-bearing objection A credible, well-scoped first routing layer for the snakes-on-a-plane architecture, but the physical executability of its schedules is assumed, not shown. the 3 major comments →

arxiv 2607.07822 v2 pith:22X7CIPK submitted 2026-07-08 quant-ph cs.ET

Routing Techniques for Error-Corrected Silicon Spin Qubit Quantum Architectures

Julian Shen , Ludwig Schmid , Robert Wille This is my paper
classification quant-ph cs.ET MSC 81P68
keywords silicon spin qubitsquantum error correctionqubit routingsnakes on a planesurface codegraph formalizationA* searchdefect handling
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

This paper is trying to establish that routing for error-corrected silicon spin qubit architectures—a problem previously left either to low-level scheduling or to error-correction-ignorant compilers—can be cleanly posed as a graph path-finding problem and solved by two algorithm families. The shortest-path family relocates idle qubits to clear lanes and works well when qubits are sparse and defects are few; the rotation family shuffles qubits around diamond cycles and keeps working even when every grid node is occupied. If correct, this gives the first high-level compilation route from logical, error-corrected quantum circuits to verified, collision-free shuttling plans for spin qubits, and it identifies the concrete trade-off that will shape future compiler design: timesteps versus qubit movements versus teleportation overhead. The reason a general reader should care is that silicon spin qubits are among the leading scalable hardware candidates, and error correction is the prerequisite for large-scale quantum computation; this paper closes part of the gap between the two.

Core claim

The paper's central claim is that the open problem of compiling logical, error-corrected circuits onto silicon spin qubits can be formalized as a discrete routing problem on a graph abstraction of the snakes-on-a-plane architecture. Within that formalization, two algorithm families—path algorithms and rotation algorithms—produce verified collision-free shuttling schedules for any given interaction sequence. The empirical discovery is that these families have opposite strengths: path algorithms minimize execution time in sparse, low-defect settings but break down once qubit density grows past roughly ten qubits on the tested grid, while rotation algorithms maintain functionality even at full

What carries the argument

The central object is a graph abstraction of the snakes-on-a-plane model: each extended physical snake collapses to a point that occupies exactly one node, stabilizer edges become capacity-1 stabilizer nodes, and interaction edges become capacity-2 interaction nodes. The routing problem is then a time-indexed path-finding problem solved with an adapted A* search and a reservation table that rejects any move violating node capacity, edge capacity, or collision constraints. The mechanism that separates the two algorithm families is how they handle tail blockage from snake surgery: path algorithms relocate idle qubits to free stabilizer nodes and teleport tails only at the destination, whereas

Load-bearing premise

The load-bearing premise, asserted rather than demonstrated at the end of Sec. IV-A, is that a collision-free schedule on the graph formalization is directly executable on the physical device: the abstraction collapses each extended snake to a point and treats snake-surgery teleportation as an abstract tail-removal event, so any physical constraint not encoded in the graph—snake length, junction geometry, teleportation latency—would invalidate the schedule.

What would settle it

Run the framework's output schedules in a cycle-accurate simulator of the snakes-on-a-plane model that models finite snake length, stabilizer-measurement times, and snake-surgery teleportation duration, on a small grid such as nine qubits on twenty-four stabilizer nodes. If a schedule the framework marks collision-free produces a physical collision, violates a stabilizer-edge timing constraint, or predicts execution time uncorrelated with the reported timesteps, the direct-mapping claim fails.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • If correct, logical spin-qubit circuits with error correction can be compiled automatically to collision-free shuttling schedules, closing the gap between abstract quantum error correction and physical spin hardware.
  • Rotation-based routing stays functional even when the grid is fully occupied, suggesting it is the right backbone for dense large-scale architectures.
  • Dynamic defect adaption—local circumvention for path algorithms, dynamic cycles for rotation algorithms—reduces execution timesteps with modest movement overhead, showing that defect-aware routing can work without full error protection.
  • Initial-mapping strategies such as reverse traversal and interaction-based placement cut both timesteps and movements by a few percent, so mapping is secondary but not negligible.
  • The identified timesteps-versus-movements-versus-teleportations trade-off gives concrete design knobs for future architecture and compiler co-design.

Where Pith is reading between the lines

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

  • If teleportation latency and finite snake length are explicitly modeled, the rotation algorithm's per-hop teleportation could dominate physical runtime, potentially overturning the paper's timestep comparison in dense settings.
  • The graph abstraction collapses each snake to a point; extending the framework to snakes spanning many physical qubits would change collision semantics and likely require post-processing of the generated schedule.
  • The layer-based decomposition and spillover mechanisms resemble packet-switching with reservations, so network-on-chip techniques for deadlock avoidance could be imported to reason about liveness of the rotation cycles.
  • A hybrid strategy—path-based routing in sparse regions, rotation-based routing in congested ones—is a natural extension that the paper does not explore.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 6 minor

Summary. The paper proposes a high-level compilation and routing framework for the 'snakes on a plane' spin-qubit architecture. It formalizes the physical routing problem as routing on a graph in which each snake is a point qubit, stabilizer edges are capacity-1 nodes, and interaction edges are capacity-2 nodes. Two routing algorithms are introduced: path algorithms (explicit collision-free path computation with idle-qubit relocation) and rotation algorithms (cyclic relocation with snake-surgery teleportation at each hop). Defect-handling strategies (waiting vs. dynamic adaption) and three initial-mapping strategies are added. The framework is evaluated on random interaction sequences on a 24-stabilizer-node grid, reporting timesteps, movements, and CPU runtime. The central claims are that shortest-path methods excel in sparse, low-defect settings, rotation-based methods scale better in dense settings, and the resulting schedules are executable on the physical architecture.

Significance. If the graph abstraction faithfully captures the physical constraints of the snakes-on-a-plane model, this is a valuable first step toward high-level routing for error-corrected spin-qubit architectures. The paper contributes two algorithm families with clear and complementary trade-offs, a concrete defect-handling and initial-mapping methodology, and an open-source implementation as part of MQT. The evaluation is reproducible and every computed schedule is verified against the graph-level collision and capacity constraints. However, the significance is conditional: the physical fidelity of the graph abstraction is asserted rather than demonstrated, and the evaluation metrics are in abstract units that may not map to physical execution cost. The contribution is therefore promising but needs additional substantiation of the abstraction and more complete empirical reporting.

major comments (3)
  1. [Sec. IV-A (last paragraph), Sec. III-B, Sec. II-C] The load-bearing translation claim — that a schedule on the graph can be 'directly mapped back to snake movements' and yields a complete physical routing plan — is not established. The graph formalization treats a snake as a point occupying one node (Sec. III-B), while the physical snake is a finite-length chain of physical qubits (Sec. II-C). Snake surgery is modeled as an instantaneous tail-removal event, but the physical protocol requires lattice-surgery doubling, head shuttling, measurement, and possible reversal. The rotation algorithm achieves full-occupancy scalability precisely by teleporting at every hop, and Sec. VI-B concedes this 'might introduce a technical overhead in practical implementations due to the required measurements.' Since timesteps and movements in Figs. 11–14 and Tab. 1 exclude this overhead, the reported trade-offs are in abstract units and may not predict phy
  2. [Sec. IV-A Step 4; Sec. II-C] The defect-handling model assumes the compiler knows which edges are defective before shuttling: 'the defect model samples all edges,' and the A* successor function rejects defective edges. The physical model, however, detects defects during shuttling via monitor qubits and the complementary gap, and then reverses via snake surgery if a defect is encountered. These are operationally different models: planning around known defective edges is not equivalent to detecting unknown defects and recovering from them. The paper should state this abstraction explicitly and justify that the defect-handling results (Figs. 12–13) are relevant to the physical detection-and-reversal process.
  3. [Sec. VI-B, VI-C, VI-E] The empirical claims of scalability and robustness are not supported by success-rate data. The retry threshold of 50 is defined and runs exceeding it are 'counted as failures,' but no failure rates are reported for any configuration. In particular, the statement that the path algorithm 'yields results only for systems with up to 10 qubits within the retry limit' (Fig. 11) and the 'improved robustness' claims in Figs. 12–13 are statements about failures, yet the plotted means do not indicate how many runs failed or whether the means are computed over successful runs only. Please report success rates (or failure rates) alongside the means, and specify how failures are treated in the averages.
minor comments (6)
  1. [Sec. III-B] The notations 'p defect' and 'p recovery' appear with an unintended space; use consistent subscripts p_defect and p_recovery throughout.
  2. [Fig. 11] Timesteps and movements have different scales and are shown on two y-axes in a single plot; consider using separate panels or normalized axes to improve readability and avoid visual over-interpretation.
  3. [Sec. VI-B] The sentence 'the path algorithm yields results only for systems with up to 10 qubits within the retry limit' is ambiguous: does the plotted curve for 11+ qubits represent zero successful runs, or are means computed over the successful subset? Please define this precisely and report the success rate.
  4. [Sec. VI-D, Tab. 1] The comparison of mapping strategies uses different qubit counts for the two algorithms (9 for path, full occupancy for rotation). This is acceptable per-algorithm, but the table should state this clearly in a caption or footnote so the reader does not compare the two algorithms directly.
  5. [Sec. II-A and related work] The discussion of prior spin-qubit compilation work is brief; a short qualitative comparison with SpinQ [13] and BeSnake [14], noting the differences in architectural model and routing objectives, would help position the contribution.
  6. [Sec. V-B] The A* heuristic is the Chebyshev distance, which is admissible for the movement cost if moves are unit-cost on a grid; consider stating explicitly that the heuristic is admissible and consistent, or note any caveats for the non-grid interaction nodes.

Circularity Check

0 steps flagged

No significant circularity: the paper's routing algorithms are evaluated on their own graph abstraction, but no central claim reduces by construction to its inputs or to self-citation.

full rationale

The derivation chain is self-contained in the sense required by the circularity analysis. The paper formalizes the snakes-on-a-plane architecture into a graph (Sec. III-B), defines a routing problem on that graph, and evaluates the proposed algorithms on the same graph with hand-chosen but not fitted parameters (p_defect=1%, p_recovery=25%, retry threshold 50, depth-10 circuits). No parameter is calibrated to the evaluation outcome and then reported as a prediction; timesteps and movements are computed outputs of the algorithms. The only author self-citation is Ref. [40] for the MQT software release, which is not load-bearing for the algorithmic claims. The rotation algorithm's scalability under full occupancy follows from the explicitly stated design choice to perform snake-surgery teleportation at every hop (Sec. IV-A3), and the paper openly acknowledges that this 'might introduce a technical overhead in practical implementations due to the required measurements,' so the trade-off is not smuggled in. The main weakness is the unverified bridge between the graph formalization and the physical model: the assertion at the end of Sec. IV-A that graph schedules 'can be directly mapped back to snake movements' and 'yields a complete routing plan' is an assumption about fidelity of the abstraction, not a circular reduction. That is a validation/correctness gap, not a circularity defect.

Axiom & Free-Parameter Ledger

6 free parameters · 6 axioms · 0 invented entities

The framework contributes no new physical entities and fits no parameters to experimental data; its free parameters are hand-chosen simulation constants and design weights. The load-bearing external inputs are the snakes-on-a-plane architecture and its defect/teleportation model (both from [18]), plus the paper's own assertion that its point-qubit graph abstraction preserves the routing-relevant physics. These are reasonable assumptions for a design-automation paper, but they mean the evaluation validates algorithms against an abstraction, not against hardware.

free parameters (6)
  • p_defect = 0.01
    Probability per edge of becoming defective; 'chosen to represent a low but non-negligible fault rate' (Sec. VI-A). Hand-set simulation parameter shaping the defect-handling evaluation.
  • p_recovery = 0.25
    Probability a defective edge recovers; 'allows defects to persist long enough to affect execution' (Sec. VI-A). Hand-set.
  • retry_threshold = 50
    Maximum consecutive routing attempts before a run counts as failure (Sec. VI-A). Hand-set; directly affects which algorithms 'remain reliable' and therefore the scalability claim.
  • grid_size = 24 stabilizer nodes (single topology)
    All experiments run on one architecture grid (Fig. 5a), chosen as 'large enough to provide a non-trivial routing problem while still being small enough' (Sec. VI-A); scalability conclusions extrapolate from this single topology.
  • circuit_depth = 10 layers
    Randomly generated interaction sequences are fixed to depth 10 (Sec. VI-A); deeper or structured QEC workloads are not tested.
  • cost_model = lexicographic (moves, time), moves prioritized
    A* cost tuple (moves, time) with moves lexicographically prioritized ('physical qubit movement is more expensive than waiting', Sec. V-B). This design choice determines computed optimality and shapes the movement-vs-timestep trade-off results.
axioms (6)
  • domain assumption The snakes on a plane model [18] is a valid buildable architecture for error-corrected silicon spin qubits
    The entire framework is built on this model (Sec. II-C); the fidelity of snakes-on-a-plane to real hardware is taken wholesale from the cited architecture paper and not independently validated here.
  • ad hoc to paper The point-qubit graph abstraction is a lossless encoding of all routing-relevant physical constraints
    Asserted at the end of Sec. IV-A: schedules on the graph 'can be directly mapped back to snake movements.' Snakes become point qubits and snake surgery becomes abstract tail removal/teleportation, with no proof of equivalence.
  • domain assumption Defect dynamics: edges fail with p_defect, recover with p_recovery, and defective traversals are corrected by snake surgery teleportation
    Adopted from [18] (Sec. II-C, Sec. III-B). The defect-handling evaluation (RQ2) is only as valid as this model's match to charge-noise physics.
  • domain assumption Physical qubit movement is more expensive than waiting; hence moves are lexicographically prioritized over time
    Stated in Sec. V-B: 'Since physical qubit movement is more expensive than waiting, the number of moves is prioritized over time.' This underlies the (moves, time) cost and the movement-vs-timestep comparisons.
  • domain assumption Magic-state preparation/distribution and QEC schedule construction are already resolved before routing
    Explicit restriction in Sec. III and Sec. IV-A: 'we assume that magic-state preparation and decomposition are already resolved and focus on the routing task.' The framework covers only routing of two-qubit interactions, not full fault-tolerant compilation.
  • standard math Standard results for A* and admissible heuristics (Chebyshev) hold
    Sec. V-B uses A* (per Hart-Nilsson-Raphael [38]) with the Chebyshev heuristic; standard optimality results are invoked without proof.

pith-pipeline@v1.3.0-alltime-deepseek · 13852 in / 24454 out tokens · 203741 ms · 2026-08-02T08:00:16.861854+00:00 · methodology

0 comments
read the original abstract

Silicon spin qubits have emerged as a promising qubit technology due to their favorable scaling and fabrication properties. However, efficiently compiling quantum circuits onto spin qubit platforms remains challenging, particularly when accounting for hardware constraints and the high sensitivity to static defects. Existing compilation approaches for spin qubits either largely ignore error correction, despite its critical role for large-scale quantum computation, or focus on low-level schedule constructions, missing a high-level compilation and routing for logical, error-corrected algorithms. To address this gap, we introduce a compilation framework for spin qubits based on the recent snakes on a plane model, which utilizes a 2D surface code and qubit teleportation to mitigate errors. Building on this model, we propose shortest-path and rotation-based algorithms as two novel classes of qubit-routing techniques, along with additional defect-handling and initial-mapping strategies. We evaluate both algorithms across diverse architectural settings and problem sizes, demonstrating that shortest-path methods excel in sparse, low-defect scenarios, while rotation-based approaches perform better in high-density environments. An open-source implementation of our framework is publicly available on GitHub as part of the Munich Quantum Toolkit (MQT) at https://github.com/munich-quantum-toolkit/spin-qubit-routing.

Figures

Figures reproduced from arXiv: 2607.07822 by Julian Shen, Ludwig Schmid, Robert Wille.

Figure 1
Figure 1. Figure 1: Sketch of the snakes on a plane architecture [18]. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Illustration of the snake surgery protocol [18]. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Routing challenges in the snakes on a plane model [18]. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figure 2
Figure 2. Figure 2: As a result of the snake surgery protocol, the red [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 5
Figure 5. Figure 5: Illustration of path and rotation schemes. [PITH_FULL_IMAGE:figures/full_fig_p005_5.png] view at source ↗
Figure 7
Figure 7. Figure 7: Overview of the complete compilation flow. [PITH_FULL_IMAGE:figures/full_fig_p006_7.png] view at source ↗
Figure 9
Figure 9. Figure 9: a. The orange and green active qubits rotate simultaneously within the same cycle, leaving no opportunity for the gray qubits to relocate. In such cases, the active qubits must be shuttled sequentially. Example 13. Consider the scenario illustrated in Fig. 9b. The orange and green active qubits rotate simultaneously in neighboring cycles, forcing the central gray idle qubit to relocate in two conflicting d… view at source ↗
Figure 10
Figure 10. Figure 10: The recursive relocation process. interactions in a reduced interaction set. We refer to this newly created layer as the spillover layer. If routing fails for all interactions in a spillover layer, the algorithm repeatedly explores alternative, possibly non-optimal meeting and target node assignments until either a feasible path is found or a predefined retry threshold is exceeded. C. Qubit Relocation For… view at source ↗
Figure 11
Figure 11. Figure 11: Comparison of path and rotation schemes as qubit [PITH_FULL_IMAGE:figures/full_fig_p009_11.png] view at source ↗
Figure 13
Figure 13. Figure 13: Effects of dynamic adaption on rotation algorithms. [PITH_FULL_IMAGE:figures/full_fig_p009_13.png] view at source ↗
Figure 14
Figure 14. Figure 14: Impact of qubit count on CPU runtime. algorithm that keeps the path-computation complexity within certain bounds, at the cost of optimality. The development of such large-scale algorithms will be future work, based on the insights from the routing methods studied in this work. VII. CONCLUSION In this work, we presented a compilation framework for spin qubit quantum computers based on the snakes on a plane… view at source ↗

Review history (2 revisions) →

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 1 Pith paper

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

  1. A route to damage tolerance exceeding $10\%$ in shuttling-equipped quantum processors

    quant-ph 2026-07 conditional novelty 6.0

    Shuttling-based spin-qubit surface codes retain roughly half their effective code distance at 10% hardware damage, so oversizing by ~2x can compensate.

Reference graph

Works this paper leans on

40 extracted references · 2 linked inside Pith · cited by 1 Pith paper

  1. [1]

    Linear optical quantum computing with photonic qubits,

    P. Kok, W. J. Munro, K. Nemotoet al., “Linear optical quantum computing with photonic qubits,”Reviews of Modern Physics, 2007

    2007

  2. [2]

    Quantum Informa- tion Processing Using Quantum Dot Spins and Cavity QED,

    A. Imamoglu, D. D. Awschalom, G. Burkardet al., “Quantum Informa- tion Processing Using Quantum Dot Spins and Cavity QED,”Physical Review Letters, 1999

    1999

  3. [3]

    Quantum Computations with Cold Trapped Ions,

    J. I. Cirac and P. Zoller, “Quantum Computations with Cold Trapped Ions,”Physical Review Letters, 1995

    1995

  4. [4]

    Quantum computing with neutral atoms,

    L. Henriet, L. Beguin, A. Signoleset al., “Quantum computing with neutral atoms,”Quantum, 2020

    2020

  5. [5]

    Superconducting Qubits: Current State of Play,

    M. Kjaergaard, M. E. Schwartz, J. Braum ¨ulleret al., “Superconducting Qubits: Current State of Play,”Annual Review of Condensed Matter Physics, 2020

    2020

  6. [6]

    Few electron double quantum dot in an isotopically purified 28Si quantum well,

    A. Wild, J. Kierig, J. Saileret al., “Few electron double quantum dot in an isotopically purified 28Si quantum well,”Applied Physics Letters, 2012

    2012

  7. [7]

    Silicon quantum electronics,

    F. A. Zwanenburg, A. S. Dzurak, A. Morelloet al., “Silicon quantum electronics,”Reviews of Modern Physics, 2013

    2013

  8. [8]

    A digitally controlled silicon quantum processing unit,

    Members of the HRL Quantum Team and Collaborators, “A digitally controlled silicon quantum processing unit,” 2026, arXiv: 2604.16216 [quant-ph]

    Pith/arXiv arXiv 2026

  9. [9]

    An addressable quantum dot qubit with fault-tolerant control-fidelity,

    M. Veldhorst, J. C. C. Hwang, C. H. Yanget al., “An addressable quantum dot qubit with fault-tolerant control-fidelity,”Nature Nanotech- nology, 2014

    2014

  10. [10]

    Gate fidelity and coherence of an electron spin in an Si/SiGe quantum dot with micromagnet,

    E. Kawakami, T. Jullien, P. Scarlinoet al., “Gate fidelity and coherence of an electron spin in an Si/SiGe quantum dot with micromagnet,” Proceedings of the National Academy of Sciences, 2016

    2016

  11. [11]

    A quantum-dot spin qubit with coherence limited by charge noise and fidelity higher than 99.9%,

    J. Yoneda, K. Takeda, T. Otsukaet al., “A quantum-dot spin qubit with coherence limited by charge noise and fidelity higher than 99.9%,” Nature Nanotechnology, 2017

    2017

  12. [12]

    Quantum logic with spin qubits crossing the surface code threshold,

    X. Xue, M. Russ, N. Samkharadzeet al., “Quantum logic with spin qubits crossing the surface code threshold,”Nature, 2022

    2022

  13. [13]

    SpinQ: Compilation Strategies for Scalable Spin-Qubit Architectures,

    N. Paraskevopoulos, F. Sebastiano, C. G. Almudever, and S. Feld, “SpinQ: Compilation Strategies for Scalable Spin-Qubit Architectures,” ACM Transactions on Quantum Computing, 2023

    2023

  14. [14]

    BeSnake: A Routing Algorithm for Scalable Spin-Qubit Architectures,

    N. Paraskevopoulos, C. G. Almudever, and S. Feld, “BeSnake: A Routing Algorithm for Scalable Spin-Qubit Architectures,”IEEE Trans- actions on Quantum Engineering, 2024

    2024

  15. [15]

    Compilation Techniques for Spin Qubits in a Shuttling Bus Architecture,

    P. Escofet, A. Semenov, N. Murphyet al., “Compilation Techniques for Spin Qubits in a Shuttling Bus Architecture,” inIEEE International Symposium on Circuits and Systems (ISCAS), 2025

    2025

  16. [16]

    Synthesizing an optimal spin- qubit shuttling-bus architecture for the surface code,

    P. Escofet, E. Alarc ´on, S. Abadalet al., “Synthesizing an optimal spin- qubit shuttling-bus architecture for the surface code,”Physical Review A, 2026

    2026

  17. [17]

    Compiling the Surface Code to Crossbar Spin Qubit Architectures,

    D. Pataki and A. P ´alyi, “Compiling the Surface Code to Crossbar Spin Qubit Architectures,”Physical Review B, 2025

    2025

  18. [18]

    Quantum Snakes on a Plane: Mobile, Low-Dimensional Logical Qubits on a 2D Surface,

    A. Siegel, Z. Cai, H. Jnaneet al., “Quantum Snakes on a Plane: Mobile, Low-Dimensional Logical Qubits on a 2D Surface,”PRX Quantum, 2026

    2026

  19. [19]

    Quantum Dots: A Primer,

    C. J. Murphy and J. L. Coffer, “Quantum Dots: A Primer,”Applied Spectroscopy, 2002

    2002

  20. [20]

    Quantum computation with quantum dots,

    D. Loss and D. P. DiVincenzo, “Quantum computation with quantum dots,”Physical Review A, 1998

    1998

  21. [21]

    Spins in few-electron quantum dots,

    R. Hanson, L. P. Kouwenhoven, J. R. Pettaet al., “Spins in few-electron quantum dots,”Reviews of Modern Physics, 2007

    2007

  22. [22]

    Conveyor-mode single-electron shuttling in Si/SiGe for a scalable quantum computing architecture,

    I. Seidler, T. Struck, R. Xueet al., “Conveyor-mode single-electron shuttling in Si/SiGe for a scalable quantum computing architecture,” npj Quantum Information, 2022

    2022

  23. [23]

    Compilation and scaling strategies for a silicon quantum processor with sparse two-dimensional connectivity,

    O. Crawford, J. R. Cruise, N. Mertig, and M. F. Gonzalez-Zalba, “Compilation and scaling strategies for a silicon quantum processor with sparse two-dimensional connectivity,”npj Quantum Information, 2023

    2023

  24. [24]

    An Efficient Routing Optimization Framework for Silicon-Based Spin-Qubit Devices,

    C.-Y . Huang and W.-K. Mak, “An Efficient Routing Optimization Framework for Silicon-Based Spin-Qubit Devices,” inIEEE Interna- tional Conference On Computer Aided Design (ICCAD), 2025

    2025

  25. [25]

    Dephasing of Si spin qubits due to charge noise,

    D. Culcer, X. Hu, and S. Das Sarma, “Dephasing of Si spin qubits due to charge noise,”Applied Physics Letters, 2009

    2009

  26. [26]

    Modeling semiconductor spin qubits and their charge noise environment for quantum gate fidelity estimation,

    M. M. E. K. Shehata, G. Simion, R. Liet al., “Modeling semiconductor spin qubits and their charge noise environment for quantum gate fidelity estimation,”Physical Review B, 2023

    2023

  27. [27]

    Stabilizer Codes and Quantum Error Correction,

    D. Gottesman, “Stabilizer Codes and Quantum Error Correction,” 1997, arXiv: quant-ph/9705052 [quant-ph]

    Pith/arXiv arXiv 1997

  28. [28]

    Blossom V: A new implementation of a minimum cost perfect matching algorithm,

    V . Kolmogorov, “Blossom V: A new implementation of a minimum cost perfect matching algorithm,”Mathematical Programming Computation, 2009

    2009

  29. [29]

    Surface codes: Towards practical large-scale quantum computation,

    A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, “Surface codes: Towards practical large-scale quantum computation,”Physical Review A, 2012

    2012

  30. [30]

    Surface code quantum computing by lattice surgery,

    D. Horsman, A. G. Fowler, S. Devitt, and R. V . Meter, “Surface code quantum computing by lattice surgery,”New Journal of Physics, 2012

    2012

  31. [31]

    Yoked surface codes,

    C. Gidney, M. Newman, P. Brooks, and C. Jones, “Yoked surface codes,” Nature Communications, 2025

    2025

  32. [32]

    Universal Quantum Computation with Spin-1/2Pairs and Heisenberg Exchange,

    J. Levy, “Universal Quantum Computation with Spin-1/2Pairs and Heisenberg Exchange,”Physical Review Letters, 2002

    2002

  33. [33]

    Universal quantum computation with ideal Clifford gates and noisy ancillas,

    S. Bravyi and A. Kitaev, “Universal quantum computation with ideal Clifford gates and noisy ancillas,”Physical Review A, 2005

    2005

  34. [34]

    Qubit Allocation,

    M. Y . Siraichi, V . F. d. Santos, C. Collange, and F. M. Q. Pereira, “Qubit Allocation,” inIEEE International Symposium on Code Generation and Optimization (CGO), 2018

    2018

  35. [35]

    Efficient Mapping of Quantum Circuits to the IBM QX Architectures,

    A. Zulehner, A. Paler, and R. Wille, “Efficient Mapping of Quantum Circuits to the IBM QX Architectures,” inDesign, Automation and Test in Europe Conference and Exhibition (DATE), 2018

    2018

  36. [36]

    Tackling the Qubit Mapping Problem for NISQ-Era Quantum Devices,

    G. Li, Y . Ding, and Y . Xie, “Tackling the Qubit Mapping Problem for NISQ-Era Quantum Devices,” inACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), 2019

    2019

  37. [37]

    A Fast and Scalable Qubit- Mapping Method for Noisy Intermediate-Scale Quantum Computers,

    S. Park, D. Kim, M. Kweonet al., “A Fast and Scalable Qubit- Mapping Method for Noisy Intermediate-Scale Quantum Computers,” inACM/IEEE Design Automation Conference (DAC), 2022

    2022

  38. [38]

    A Formal Basis for the Heuristic Determination of Minimum Cost Paths,

    P. E. Hart, N. J. Nilsson, and B. Raphael, “A Formal Basis for the Heuristic Determination of Minimum Cost Paths,”IEEE Transactions on Systems Science and Cybernetics, 1968

    1968

  39. [39]

    C. D. Cantrell,Modern Mathematical Methods for Physicists and Engineers. Cambridge University Press, 2000

    2000

  40. [40]

    The MQT Handbook : A Summary of Design Automation Tools and Software for Quantum Computing,

    R. Wille, L. Berent, T. Forsteret al., “The MQT Handbook : A Summary of Design Automation Tools and Software for Quantum Computing,” in IEEE International Conference on Quantum Software (QSW), 2024

    2024