Orchestrating Multi-Zone Shuttling in Trapped-Ion Quantum Computers

Daniel Schoenberger; Robert Wille

REVIEW 3 major objections 4 minor 30 references

Orchestrating Multi-Zone Shuttling in Trapped-Ion Quantum Computers

T0 review · 3 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read This paper proposes a compilation strategy for multi-zone trapped-ion QCCD architectures that explicitly models processing zones as linear trap regions, combines qubit partitioning with dependency-aware gate selection, and reports 52–88%…

desk verdict Solid, well-scoped compilation paper for multi-zone QCCD; the headline gains rest on treating linear shuttling as instantaneous, which needs sensitivity analysis. read the letter →

arxiv 2505.07928 v1 pith:CPXQZMXS submitted 2025-05-12 quant-ph

Daniel Schoenberger , Robert Wille This is my paper · ORCID

classification quant-ph

keywords trapped-ionquantumcomputingQCCDarchitectureionshuttlingmulti-zoneschedulingqubitpartitioningdependency-awaregateselectioncycle-basedpath-based

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 is trying to establish that multi-zone trapped-ion QCCD architectures can be compiled automatically when the processing zones are modeled explicitly as linear trap regions, rather than as black boxes. It proposes a compiler that partitions qubits among the available processing zones and then uses a dependency graph to choose, for each zone, the ready gate whose ions are closest. This reduces shuttling between zones while letting separate zones execute gates simultaneously. If the approach holds, the practical bottleneck for next-generation trapped-ion devices moves from hardware design to software scheduling, and the reported numbers quantify that: dependency-aware gate selection alone shortens schedules by 52–88% compared with executing the circuit in fixed order, and going from one to four processing zones improves schedule length by up to roughly 50–60%.

What carries the argument

The load-bearing mechanism is the path-based shuttling rule for linear processing zones, grafted onto an existing cycle-based scheduler for the memory grid. Each processing zone is modeled as a linear trap region connected to the grid by Y-junctions that give it one-way entry and exit paths; moving an ion into, through, or out of a zone shifts every ion on a directed path forward by one edge in a single time step. This explicit geometry lets the scheduler enforce zone capacity, respect gate-occupancy blocking, and route ions to the nearest free grid edge when they leave. Around this sits the orchestration layer: repeated balanced bisection of an interaction graph assigns qubits to zones, and a per-zone priority queue over the dependency graph's front layer selects gates whose ions are closest, which is what enables simultaneous gate execution.

What would settle it

Run the same compiler on an architecture whose processing zone contains an internal junction or a multi-access interface, or assign a nonzero time cost per linear edge: if schedules lengthen so much that the method no longer beats a black-box scheduler, or the multi-zone speedups disappear, the central claim about explicit linear-PZ modeling fails. A concrete check is to compare against an exact optimal schedule on a small instance (12 ions, two processing zones, QFT).

Watch

Extended reading notes

Core claim

The central claim is that orchestrating ions across the memory grid and several external processing zones is best treated as two coupled shuttling problems: cycle-based rotation inside the grid, and path-based one-edge-per-step pushes along the one-way entry and exit lines of each processing zone. Previous work that treated processing zones as black boxes, according to the paper, missed constraints that matter for scheduling, such as zone capacity and gate-occupancy blocking. The paper's method integrates a graph bisection step that maps frequently interacting qubits to the same zone with a per-zone priority queue over the circuit's dependency graph, so each zone picks the closest available gate. Empirical evaluation on GHZ, QFT, and random circuits across grids from 12 to 72 ions and one to four processing zones reports valid schedules for all tested layouts, with the gate-selection component contributing the dominant speedup.

Load-bearing premise

The model assumes every processing zone is a single linear trap region reached through one-way Y-junction entry and exit paths, and that moving along a linear segment costs no time; if real zones have internal junctions, multi-access interfaces, or distance-dependent shuttling costs, the path-based method and its reported benefits would need reworking.

Editorial extensions

If this is right

Multi-zone QCCD scheduling no longer needs to treat processing zones as single opaque nodes; explicit linear geometry gives valid schedules that respect capacity, one-way interfaces, and gate-occupancy blocking.
Adding processing zones to a grid memory zone buys real speedup—up to roughly 50–60% at four zones—but with diminishing returns, so device designers can choose a PZ count suited to the circuits they expect.
Most of the reported gain comes from reordering gates by dependency rather than from the extra zones, so circuits with more parallelism will benefit more from multi-zone layouts.
The same compiler handles single-zone and multi-zone devices, giving architects a direct way to compare layouts by simulated schedule length before building hardware.

Reading between the lines

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

If a processing zone is given internal junctions—a small tree of linear segments instead of one line—the path-push rule extends naturally, which would make the method applicable to the more complex PZ interfaces the paper acknowledges as conceivable.
The 52–88% and 50–60% figures compare against a fixed-order baseline and a single-zone baseline, not against an exact optimum; a SAT-based or ILP-based optimal scheduler on small grids would show how much headroom remains.
The assumed gate-time ratio (one step for single-qubit, three for two-qubit) and instantaneous linear movement mean that on hardware with slower two-qubit gates the optimal number of processing zones could shift; the tool's configurable timing parameters make this testable directly.
The exit routing rule sends ions to the nearest free memory-grid edge, which suggests that congested grids, not zone count, may become the scaling bottleneck; a dynamic re-partitioning variant would address that.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Short version: the paper does a real thing—it models multiple linear processing zones explicitly instead of black-boxing them, and it integrates qubit partitioning with DAG-aware gate selection into a working scheduler. The tool is open-source, the algorithm is fully specified, and the evaluation covers a range of grids and circuits. I'd send it to a serious referee.

What's actually new: prior work, including their own [23], treated PZs as black boxes and only handled one PZ. Here they model a PZ as a linear region with Y-junctions, add path-based shuttling for entry/exit, and wrap it in an orchestration layer that assigns qubits to PZs via Kernighan-Lin and picks front-layer gates per PZ by proximity. That is a sensible, non-trivial extension, and the paper explains it clearly. The empirical work is honest about being a simulator under a stated cost model.

The soft spots are real but not fatal. First, the cost model sets linear shuttling to zero time; only junction traversal costs a step. That is disclosed in VI-A, but the 52-88% DAG improvements and the 50-60% multi-PZ gains are computed entirely under that model. In actual QCCD hardware, shuttling along segments is timed and can heat the ions, so the optimal gate selection could change, and the headline numbers could shrink. This is a sensitivity issue, not an internal contradiction. I'd ask them to rerun with a per-segment linear movement cost (even a cheap one) and report how the comparisons hold.

Second, the empirical claims are averages over five seeds with no error bars or statistical tests. For a compilation paper that's not disqualifying, but the absence of variance makes the precise percentages feel over-precise. Third, the DAG baseline is the raw circuit order; a stronger baseline, like the single-zone scheduler from [23], would be a fairer test of what the multi-zone orchestration buys you. That baseline issue is minor because the paper also shows an absolute cross-architecture table.

The citation pattern is fine: the heavy reliance on [23] is legitimate since this is a direct extension, and the KL/DAG pieces are standard and credited. The paper acknowledges the PZ interface simplification itself.

Bottom line: this is a competent, useful contribution for anyone building compilers for next-generation trapped-ion devices. It deserves peer review; my recommendation would be to accept with requests for sensitivity analysis and error bars.

Referee Report

3 major / 4 minor

Summary. The paper proposes a compilation strategy for QCCD trapped-ion architectures with a two-dimensional grid memory zone and multiple external linear processing zones. The method explicitly models processing zones as linear trap regions connected to the grid by Y-junctions, combines Kernighan-Lin qubit partitioning with dependency-aware gate selection on a DAG, and extends an earlier cycle-based memory-zone shuttling approach with path-based shuttling through processing zones. The resulting scheduler is implemented as an open-source MQT tool and evaluated on GHZ, QFT, and random circuits across grids from 12 to 120 ions and one to four processing zones. The reported results show 52–88% time-step reductions from DAG-based gate selection and up to 50–60% improvements from adding processing zones.

Significance. If the adopted cost model is representative, this is a useful advance over prior black-box treatments of processing zones: it exposes capacity, entry/exit, and path-conflict constraints and integrates multi-zone parallelism into a single scheduling framework. The algorithm is fully specified, the implementation is open source, no parameters are fitted to manufacture the results, and the benchmark sweep covers a wide range of layouts. The work is incremental over the authors' earlier single-zone shuttling compiler [23], but the extension to multiple explicitly modeled processing zones and the reported gains are concrete and falsifiable. The main weakness is that the quantitative claims currently rest on a cost model and an evaluation methodology that are not yet sufficient to support the headline efficiency numbers.

major comments (3)

[VI-A, IV-B] The cost model sets junction traversal to one time step while treating shuttling along linear paths as instantaneous, and path-based shuttling advances all ions on a path by one edge per time step regardless of path length. Figures 4 and 5 and Table I are all computed under this model. In real QCCD devices, linear transport is a timed physical operation that can dominate schedule length, so the reported 52–88% and 50–60% improvements may not transfer to the target hardware. The paper itself acknowledges that 'more complex PZ interface designs are conceivable,' but it does not test the sensitivity of the results to nonzero linear shuttling costs; a sensitivity analysis with per-edge linear movement costs, or a clear delimitation of the claims to junction-dominated cost models, is needed before the empirical conclusions can be accepted.
[VI-B, Table I, Figures 4-5] All quantitative claims are based on means over five random seeds, with no error bars, standard deviations, or statistical tests. Several adjacent configurations differ by only a few percent; for example, Table I reports 1361.6 vs. 1360.8 time steps for GHZ on the (3,3,5,5) architecture with three vs. four processing zones, which is essentially no difference. Without a measure of dispersion, the claims of consistent improvements and of diminishing returns from additional processing zones are not statistically supported. The authors should report distributions and, where appropriate, paired significance tests across the seeds.
[III, VI-B] The evaluation isolates DAG-based gate selection and the number of processing zones, but it never compares the explicit processing-zone model against a black-box processing-zone abstraction. Since the stated novelty over previous work, including [23], is the explicit structural modeling of processing zones, an experiment that varies only the processing-zone abstraction is required to support that claim. In addition, the 'without DAG' baseline is a naive fixed-order gate-by-gate schedule, so the 52–88% improvement figure should not be interpreted as a comparison against an alternative optimizing scheduler; at minimum, the baseline should be described as such and the claim worded accordingly.

minor comments (4)

[VI] There is a typo in the opening sentence of Section VI: 'we evaluatete' should be 'we evaluate'.
[Table I] The table header uses G, T, t, and CPU time, but only G and CPU time are explained in the text; the distinction between T (average time steps) and t should be made explicit in the caption or surrounding text.
[Figure 2] The caption of Figure 2 contains stray markup artifacts (|q!⟩ etc.) that should be replaced with proper subscripts or LaTeX notation.
[V-C] Algorithm 1 has no termination or correctness argument; given that the scheduler must make progress under capacity limits, path conflicts, and simultaneous cycles, a brief invariant or proof outline would strengthen the claim that the tool reliably produces valid schedules.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation; the multi-zone orchestration claims are evaluated under an explicitly stated cost model, with only a minor non-load-bearing self-citation to the authors' prior cycle-based shuttling work.

full rationale

The paper's derivation chain is an algorithmic compilation flow: a graph model of a grid memory zone with linear processing zones, path-based shuttling for PZ entry/exit, KL-based qubit partitioning, DAG-based gate selection, and a simulator that counts time steps under the assumptions in Section VI-A ('junction traversal takes one time step while shuttling along linear paths is instantaneous'; single-qubit gates one time step, two-qubit gates three). No parameter is fitted to the target result, and the reported improvements (52–88% for DAG-based selection, 50–60% for multiple PZs) are direct comparisons against stated baselines under the same cost model, not predictions derived from fitted inputs. The only author self-citation is the reuse of the cycle-based shuttling algorithm and priority-queue mechanism from the authors' earlier work [23] (Sections IV-A and V-B). That reuse is disclosed and is not load-bearing for the paper's central novelty of explicitly modeling multiple linear PZs and orchestrating them; the cited work is not invoked as a uniqueness theorem and does not define away the new contribution. The 'linear shuttling is instantaneous' assumption is a clearly stated modeling choice that could affect external validity on real hardware, but it is not a circular step because the schedule length is not defined in terms of the conclusions drawn from it. Thus, there is no significant circularity beyond a minor, non-load-bearing self-citation pattern.

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

The central claim rests on a hardware model of grid memory zones plus linear processing zones connected by Y-junctions, on the prior cycle-based shuttling method, and on chosen time-cost parameters. No free parameter is fitted to data; the gate-time and movement costs are configurable assumptions.

free parameters (5)

single_qubit_gate_time = 1 time step
Set in Section VI-A; configurable; affects schedule lengths but not algorithmic structure.
two_qubit_gate_time = 3 time steps
Set in Section VI-A to reflect typical slower two-qubit gates; configurable.
junction_traversal_time = 1 time step
Set in Section VI-A; configurable.
linear_shuttling_time = 0 time steps (instantaneous)
Set in Section VI-A; optimistic simplification; could be length-dependent in real hardware.
PZ capacity = 2 ions
Design choice in Section VI-A; assumed to fit two-qubit gates.

assumptions (5)

domain assumption Within the memory zone grid, ions cannot directly swap positions; conflict-free movement uses cycles that rotate ions along closed loops.
Stated in Section IV-A, inherited from [23]; foundational to the cycle-based shuttling.
domain assumption Processing zones are linear trap regions connected to the grid via Y-junctions with one-way entry and exit paths.
Stated in Section IV-B; the paper acknowledges other topologies are conceivable, making this a load-bearing modeling choice.
domain assumption A single time step suffices for every edge shift along a path or cycle, and linear path shuttling is instantaneous while junction traversal costs one step.
Stated in Section VI-A; the cost model shapes the reported improvements.
domain assumption Gate execution in a processing zone blocks access to that zone for the gate duration.
Stated in Section IV-B Constraints; the orchestration scheduler accounts for these timings.
standard math DAG front-layer gates are mutually commutative and can be executed in parallel.
Used in Section V-B; holds for the DAG representation because front-layer gates act on disjoint qubit sets.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Orchestrating Multi-Zone Shuttling in Trapped-Ion Quantum Computers." pith.science (2026). https://pith.science/paper/CPXQZMXS

@misc{pith2026250507928,
  author       = {Pith},
  title        = {Pith review of: Orchestrating Multi-Zone Shuttling in Trapped-Ion Quantum Computers},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/CPXQZMXS}},
  note         = {Machine review of arXiv:2505.07928}
}

read the original abstract

Trapped-ion quantum computers are a promising platform, offering high-quality qubits with long coherence times and high-fidelity gate operations. The Quantum Charge Coupled Device (QCCD) architecture provides a scalable blueprint by leveraging the ability to shuttle ions between distinct zones. However, realizing such architectures in practice requires software support to manage ion movement across multi-zone layouts. In this work, we propose a compilation strategy for QCCD architectures with multiple processing zones located outside a grid-type memory zone. Unlike previous approaches that treat processing zones as black-boxes, our method explicitly models their structural constraints, enabling optimized ion movement to and through them. It combines qubit partitioning with dependency-aware gate selection to reduce inter-zone shuttling while enabling simultaneous gate execution. We implemented the method in an open-source tool and empirically demonstrated its effectiveness across several QCCD layouts, laying a foundation for the compilation of multi-zone trapped-ion systems.

Figures

Figures reproduced from arXiv: 2505.07928 by the authors.

**Figure 2.** Comparison of cycle-based shuttling within the MZ and path-based shuttling through a linear PZ. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** Compilation steps prompting the construction of three cycles to clear the way. In Figure 2b, an ion is trying to enter the entry to the PZ. To make room for the ion, a path is constructed to the PZ edge. To move ions out of the PZ edge, the path leading from the PZ edge to the free edge e73 in the MZ is used. Constraints: A key constraint for both entry and exit paths of a PZ is that movement may be temporarily bloc… view at source ↗

Figures from the paper (1 more)

**Figure 4.** Figure 4: Improvement in time steps executing “QFT” of using [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

30 extracted references · 26 canonical work pages

[23]

Schoenberger, S

D. Schoenberger, S. Hillmich, M. Brandl, and R. Wille, Shuttling for scalable trapped-ion quantum computers , 2024. arXiv: 2402 . 14065 [quant-ph]

work page 2024
[1]

Algorithms for quantum computation: Discrete log- arithms and factoring,

P. W. Shor, “Algorithms for quantum computation: Discrete log- arithms and factoring,” in Symp. on Foundations of Computer Science, 1994, pp. 124–134

work page 1994
[2]

A fast quantum mechanical algorithm for database search,

L. K. Grover, “A fast quantum mechanical algorithm for database search,” in Symp. on Theory of Computing, 1996, pp. 212–219

work page 1996
[3]

Low-depth quantum simulation of materials,

R. Babbush et al., “Low-depth quantum simulation of materials,” Phys. Rev. X, vol. 8, p. 011 044, 1 2018

work page 2018
[4]

Superconducting qubits: Current state of play,

M. Kjaergaard et al. , “Superconducting qubits: Current state of play,” Annual Review of Condensed Matter Physics, vol. 11, no. 1, pp. 369–395, 2020

work page 2020
[5]

Quantum computing with neutral atoms,

L. Henriet et al., “Quantum computing with neutral atoms,” Quan- tum, vol. 4, p. 327, 2020

work page 2020
[6]

Logical quantum processor based on reconfig- urable atom arrays,

D. Bluvstein et al., “Logical quantum processor based on reconfig- urable atom arrays,” Nature, vol. 626, no. 7997, pp. 58–65, 2023

work page 2023
[7]

Photonic quantum information processing: A concise review,

S. Slussarenko and G. J. Pryde, “Photonic quantum information processing: A concise review,” Applied Physics Reviews , vol. 6, no. 4, 2019

work page 2019

Show all 30 references

[8]

Demonstration of a small programmable quan- tum computer with atomic qubits,

S. Debnath et al., “Demonstration of a small programmable quan- tum computer with atomic qubits,” Nature, vol. 536, no. 7614, pp. 63–66, 2016

2016
[9]

Demonstration of the trapped-ion quantum ccd computer architecture,

J. M. Pino et al., “Demonstration of the trapped-ion quantum ccd computer architecture,” Nature, vol. 592, no. 7853, pp. 209–213, 2021

2021
[10]

S. A. Moses et al., A race track trapped-ion quantum processor ,
[11]

M. P. da Silva et al., Demonstration of logical qubits and repeated error correction with better-than-physical error rates, 2024. arXiv: 2404.02280 [quant-ph]

2024 arXiv
[12]

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

R. Wille et al. , “The MQT Handbook: A Summary of Design Automation Tools and Software for Quantum Computing,” inIEEE International Conference on Quantum Software, 2024. arXiv: 2405. 17543, A live version of this document is available at https://mqt. readthedocs.io

2024
[13]

High-fidelity preparation, gates, memory, and readout of a trapped-ion quantum bit,

T. P. Harty et al., “High-fidelity preparation, gates, memory, and readout of a trapped-ion quantum bit,” Phys. Rev. Lett. , vol. 113, p. 220 501, 22 2014

2014
[14]

Quantum computations with cold trapped ions,

J. I. Cirac and P. Zoller, “Quantum computations with cold trapped ions,” Phys. Rev. Lett., vol. 74, pp. 4091–4094, 20 1995

1995
[15]

Architecture for a large-scale ion-trap quantum computer,

D. Kielpinski, C. Monroe, and D. J. Wineland, “Architecture for a large-scale ion-trap quantum computer,”Nature, vol. 417, no. 6890, pp. 709–711, 2002

2002
[16]

Ar- chitecting noisy intermediate-scale trapped ion quantum comput- ers,

P. Murali, D. M. Debroy, K. R. Brown, and M. Martonosi, “Ar- chitecting noisy intermediate-scale trapped ion quantum comput- ers,” in International Symposium on Computer Architecture, 2020, pp. 529–542

2020
[17]

Exact physical design of quantum circuits for ion-trap-based quantum architec- tures,

O. Kesz ¨ocze, N. Mohammadzadeh, and R. Wille, “Exact physical design of quantum circuits for ion-trap-based quantum architec- tures,” 2021 Design, Automation & Test in Europe Conference & Exhibition (DATE), pp. 344–349, 2021

2021
[18]

Muzzle the shuttle: Efficient compilation for multi-trap trapped-ion quantum comput- ers,

A. A. Saki, R. O. Topaloglu, and S. Ghosh, “Muzzle the shuttle: Efficient compilation for multi-trap trapped-ion quantum comput- ers,” in 2022 Design, Automation &; Test in Europe Conference &; Exhibition (DATE), 2022, pp. 322–327

2022
[19]

Backend compiler phases for trapped-ion quan- tum computers,

T. Schmale et al., “Backend compiler phases for trapped-ion quan- tum computers,” in 2022 IEEE International Conference on Quan- tum Software (QSW), 2022

2022
[20]

Quantum circuit compiler for a shuttling-based trapped-ion quantum computer,

F. Kreppel et al., “Quantum circuit compiler for a shuttling-based trapped-ion quantum computer,” Quantum, vol. 7, p. 1176, 2023

2023
[21]

Quantum circuit compilation for trapped-ion processors with the drive-through architecture,

C.-M. Chang, J.-H. R. Jiang, D.-W. Chiou, T. Hsu, and G.-D. Lin, “Quantum circuit compilation for trapped-ion processors with the drive-through architecture,” IEEE Transactions on Quantum Engineering, pp. 1–14, 2025

2025
[22]

Using Boolean satisfiability for exact shuttling in trapped-ion quantum computers,

D. Schoenberger, S. Hillmich, M. Brandl, and R. Wille, “Using Boolean satisfiability for exact shuttling in trapped-ion quantum computers,” in Asia and South-Pacific Design Automation Conf. , 2024

2024
[24]

An efficient heuristic procedure for partitioning graphs,

B. W. Kernighan and S. Lin, “An efficient heuristic procedure for partitioning graphs,” The Bell System Technical Journal , vol. 49, no. 2, pp. 291–307, 1970

1970
[25]

Javadi-Abhari et al

A. Javadi-Abhari et al. , Quantum computing with qiskit , 2024. arXiv: 2405.08810 [quant-ph]

2024 arXiv
[26]

MQT Bench: Bench- marking software and design automation tools for quantum com- puting,

N. Quetschlich, L. Burgholzer, and R. Wille, “MQT Bench: Bench- marking software and design automation tools for quantum com- puting,” Quantum, vol. 7, p. 1062, 2023

2023
[27]

T—ket〉: A retargetable compiler for nisq de- vices,

S. Sivarajah et al., “T—ket〉: A retargetable compiler for nisq de- vices,” Quantum Science and Technology, vol. 6, no. 1, p. 014 003, 2020

2020
[28]

Fast quantum logic gates with trapped-ion qubits,

V . M. Sch ¨afer et al., “Fast quantum logic gates with trapped-ion qubits,” Nature, vol. 555, no. 7694, pp. 75–78, 2018

2018
[29]

K. R. Brown, J. Kim, and C. Monroe, Co-designing a scalable quantum computer with trapped atomic ions , 2016. arXiv: 1602 . 02840 [quant-ph]

2016
[2023]

arXiv: 2305.03828 [quant-ph]

arXiv

Pith tools

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

[1] [23]

Schoenberger, S

D. Schoenberger, S. Hillmich, M. Brandl, and R. Wille, Shuttling for scalable trapped-ion quantum computers , 2024. arXiv: 2402 . 14065 [quant-ph]

work page 2024

[2] [1]

Algorithms for quantum computation: Discrete log- arithms and factoring,

P. W. Shor, “Algorithms for quantum computation: Discrete log- arithms and factoring,” in Symp. on Foundations of Computer Science, 1994, pp. 124–134

work page 1994

[3] [2]

A fast quantum mechanical algorithm for database search,

L. K. Grover, “A fast quantum mechanical algorithm for database search,” in Symp. on Theory of Computing, 1996, pp. 212–219

work page 1996

[4] [3]

Low-depth quantum simulation of materials,

R. Babbush et al., “Low-depth quantum simulation of materials,” Phys. Rev. X, vol. 8, p. 011 044, 1 2018

work page 2018

[5] [4]

Superconducting qubits: Current state of play,

M. Kjaergaard et al. , “Superconducting qubits: Current state of play,” Annual Review of Condensed Matter Physics, vol. 11, no. 1, pp. 369–395, 2020

work page 2020

[6] [5]

Quantum computing with neutral atoms,

L. Henriet et al., “Quantum computing with neutral atoms,” Quan- tum, vol. 4, p. 327, 2020

work page 2020

[7] [6]

Logical quantum processor based on reconfig- urable atom arrays,

D. Bluvstein et al., “Logical quantum processor based on reconfig- urable atom arrays,” Nature, vol. 626, no. 7997, pp. 58–65, 2023

work page 2023

[8] [7]

Photonic quantum information processing: A concise review,

S. Slussarenko and G. J. Pryde, “Photonic quantum information processing: A concise review,” Applied Physics Reviews , vol. 6, no. 4, 2019

work page 2019