Quantum Logic Gates: Principles, Physical Implementations and Recent Progress

From “rotating a qubit” to fault-tolerant logical gates: how a quantum computer actually performs one step of a computation (as of October 2026)

1 From classical to quantum logic gates

Everything a classical computer does is ultimately carried out by logic gates such as AND, OR and NOT: they take some 0/1 inputs and produce a definite 0/1 output. A quantum computer also needs “logic gates”, but they act on quantum bits (qubits). A qubit can be in a superposition α|0⟩ + β|1⟩ of |0⟩ and |1⟩, where α and β are complex numbers; on measurement it yields 0 with probability |α|² and 1 with probability |β|²^[1].

Quantum gates differ from classical gates in three fundamental ways. First, ideal quantum gates are reversible. Mathematically, every quantum gate is a unitary transformation, so any gate can be exactly “undone” by another gate; a classical AND gate cannot, because an output of 0 does not tell you whether the input was 00, 01 or 10^[2]. Second, quantum gates act on superpositions. A gate acts on every component of a superposition at once, and the amplitudes of many qubits can interfere with each other, which is the source of quantum speed-ups. Third, quantum gates cannot copy unknown states. The no-cloning theorem shows that no gate can make a copy of an arbitrary unknown quantum state^[3]; the “backups” taken for granted in classical computing are impossible, which is one reason quantum error correction is harder than its classical counterpart.

It is also important to distinguish gates from measurement. A gate is a reversible evolution (some gates are discrete, such as H and T; others are rotations with a tunable angle); a measurement “collapses” a superposition into a classical outcome and is irreversible. A quantum program (a quantum circuit) typically runs: initialise all qubits to |0⟩ → apply a sequence of gates → measure at the end. This report uses this “circuit model”. Note, however, that fault-tolerant quantum computing also relies heavily on non-unitary operations such as mid-circuit measurement, qubit reset and real-time adjustment of later operations based on measurement outcomes (classical feed-forward); these appear in Section 6.

For a single qubit there is a very intuitive geometric picture: the Bloch sphere. Ignoring an unobservable global phase, every pure state of one qubit corresponds to a point on a sphere: the north pole is |0⟩, the south pole |1⟩, and the equator holds equal-weight superpositions. Every single-qubit gate is equivalent to a rotation of this sphere about some axis (Figure 1)^[1]. This turns abstract matrix operations into something one can picture: the X gate is a half-turn about the x axis that flips |0⟩ into |1⟩, like a classical NOT; the Z gate is a half-turn about the z axis that leaves the 0/1 measurement probabilities unchanged and changes only the phase; the T gate rotates about the z axis by just one eighth of a turn (π/4).

Figure 1 The Bloch sphere and the geometric meaning of single-qubit gates. Left: a quantum state is a point on the sphere, with |0⟩ at the north pole, |1⟩ at the south pole and equal-weight superpositions on the equator. Right: rotation axes and angles of common single-qubit gates. Phase (rotation about the z axis) does not change the 0/1 measurement probabilities but affects later results through interference.

2 Common quantum gates

Table 1 summarises the most common quantum gates. Two classes are especially important: single-qubit gates “set the direction”, while entangling two-qubit gates can create entanglement between qubits for suitable input states. Without entangling gates, a set of qubits is just a collection of independent coins and cannot deliver the power of quantum computing.

Table 1 Common quantum logic gates

“Clifford gates” are gates composed of H, S and CNOT; circuits consisting only of these gates together with stabilizer states and Pauli measurements can be simulated efficiently on a classical computer^[4]. Non-Clifford resources such as T and Toffoli gates are required to escape efficient stabilizer simulation and, together with Clifford operations, enable universal quantum computation; they also dominate the cost of fault tolerance. Rotation angles refer to the Bloch sphere.

The most widely used two-qubit gate is the controlled-NOT (CNOT): if the control qubit is 1 it flips the target qubit, otherwise it does nothing. On 0/1 inputs it keeps the control bit and replaces the target bit with the XOR of the two; unlike a classical XOR gate, it is reversible. When acting on suitable superposition inputs, however, CNOT can entangle the two qubits. Figure 2 shows the simplest example: one H gate plus one CNOT turns |00⟩ into the Bell state (|00⟩ + |11⟩)/√2. Measuring either qubit alone then gives a random 0 or 1, but the two outcomes always agree.

Figure 2 A quantum circuit that prepares an entangled (Bell) state with two gates. Horizontal lines show qubits evolving in time, boxes are single-qubit gates, and the filled dot connected to ⊕ forms a CNOT gate (dot = control, ⊕ = target). The state after each step is shown below.

Different hardware platforms are “naturally” good at different two-qubit gates: superconducting chips commonly use controlled-phase (CZ) or iSWAP-like gates, trapped ions use Mølmer–Sørensen or ZZ phase gates, and neutral atoms mainly use CZ gates. These gates can be converted into one another mathematically (for example, CNOT equals CZ with an H gate on each side of the target qubit), so a compiler translates an algorithm's gates into each platform's native gates, a step called compilation or gate synthesis. The choice of native gates affects circuit depth and hence accumulated error.

3 Universal gate sets: building any computation from a finite set of “bricks”

A foundational result of quantum computing theory is that arbitrary single-qubit rotations together with the CNOT gate suffice to decompose exactly any multi-qubit quantum operation^[5]; more generally, any entangling two-qubit gate, supplemented by arbitrary single-qubit gates, has this “universality”^[6,7]. This parallels the classical result that NAND gates suffice to build any circuit.

But there are infinitely many rotation angles, while fault-tolerant architectures commonly expose only a finite set of logical primitives. Arbitrary rotations are therefore obtained by approximation: gates from a discrete universal gate set are combined to approach the target rotation to the required precision. The Solovay–Kitaev theorem guarantees that, for precision ε, the number of gates needed grows only polynomially in log(1/ε)^[8]; for generic single-qubit z rotations without ancilla qubits, modern optimal algorithms typically need about 3·log₂(1/ε) T gates plus small lower-order terms. For ε = 10⁻¹⁰, that is roughly 100 T gates^[9].

The most widely used finite gate set in fault-tolerant quantum computing is Clifford + T. Clifford gates include H, S and CNOT. The Gottesman–Knill theorem states that circuits consisting only of stabilizer-state preparation, Clifford gates and Pauli measurements (stabilizer circuits) can be simulated efficiently on a classical computer^[4]. In other words, universal quantum computation requires an additional non-Clifford resource: either a directly implemented non-Clifford gate (most commonly the T gate, or the three-qubit Toffoli gate), or special non-stabilizer input states known as “magic states” (see Section 6). This distinction matters greatly in engineering terms: in mainstream error-correcting codes such as the surface code, Clifford gates are relatively easy to implement fault-tolerantly, while T gates usually consume magic states and are the main cost of fault-tolerant computation (see Section 6). Resource estimates for quantum algorithms are therefore often expressed in terms of T-count or Toffoli count; the standard decomposition of a Toffoli gate uses 7 T gates, which can be reduced to 4 with ancilla qubits and measurement^[10].

4 How gates are “made”: physical implementations on each platform

In hardware, “applying a gate” means applying precisely controlled external fields (microwaves, laser light, voltage pulses, etc.) to qubits for a precisely controlled time, so that the quantum state evolves as intended. A single-qubit gate is usually a resonant drive on one qubit; a two-qubit gate requires two qubits to interact in a controlled way for some time, after which the interaction is “switched off”. Implementations differ greatly across platforms (Table 2).

Table 2 How each platform implements quantum gates, with representative metrics (as of October 2026)

* Preprint. Metrics come from different systems and protocols: system averages versus single-pair best values, isolated versus simultaneous operation, and treatment of loss events differ, so comparisons are indicative of orders of magnitude only. Each cell states its metric type (system-wide average, single-pair best value, etc.).

• Superconducting qubits. Single-qubit gates are microwave pulses lasting tens of nanoseconds. Because a transmon is not a strict two-level system, pulses must be shaped (for example with the Derivative Removal by Adiabatic Gate, DRAG, technique) to avoid exciting the qubit to higher levels, an effect called “leakage”^[11]. There are two main routes to two-qubit gates: tunable couplers that “switch on” the interaction between two qubits when needed, implementing CZ or iSWAP-like gates^[12]; and cross-resonance gates between fixed-frequency qubits^[13]. Google's Willow error-correction chip uses CZ gates, while its random-circuit-sampling chip uses iSWAP-like gates^[14].
• Trapped ions. Single-qubit gates can be driven by lasers or microwaves; an Oxford team driving ⁴³Ca⁺ ions with microwaves achieved an average error of 1.5×10⁻⁷ per single-qubit Clifford gate (randomised benchmarking), one of the lowest single-qubit Clifford-gate errors published to date^[16]. Two-qubit gates use the ion chain's collective vibrations (a “phonon bus”) to mediate the interaction; the early scheme was the Cirac–Zoller gate^[38], and the mainstream scheme is the Mølmer–Sørensen gate, which is substantially less sensitive to the ions' initial motional state and does not require ground-state cooling under appropriate conditions^[17]. The native two-qubit gate of Quantinuum systems is a ZZ phase gate with a continuously adjustable angle^[18]. Oxford Ionics (now part of IonQ) replaces laser control of gates with microwave and radio-frequency (RF) signals generated by on-chip electrodes^[20,39].
• Neutral atoms. Atoms barely interact in their ground state; for a two-qubit gate, lasers excite atoms to Rydberg states, and an atom in a Rydberg state prevents nearby atoms from being excited too (the “Rydberg blockade”), which yields a CZ gate^[21,22]. CZ gates typically take a few hundred nanoseconds; in 2023 a Harvard team reported CZ gates with 99.5% fidelity running in parallel on up to 60 atoms^[23]. Because optical tweezers can move atoms, software decides which pairs of qubits interact.
• Silicon spin qubits. Single-qubit gates use electron spin resonance (magnetic or electric driving); two-qubit gates exploit the “exchange interaction” between electrons in neighbouring quantum dots, switched on and off by gate voltages, to implement CZ, controlled-rotation (CROT) or √SWAP gates in about 100 ns^[25–27]. In 2022 two teams reported two-qubit gate fidelities above 99%^[28,29], and in 2025 devices from a 300 mm foundry line also exceeded 99%^[30].
• Photonic qubits. In mainstream linear-optical schemes, single-qubit gates on a photon (waveplates, phase shifters) are nearly deterministic and highly accurate, conditional on the photon not being lost; but photons do not interact directly, so two-qubit gates can only be implemented “probabilistically” using ancilla photons and measurement^[31]. Leading fault-tolerant schemes, such as fusion-based quantum computation, no longer rely on two-qubit gates in the traditional sense; instead they stitch small entangled states into large cluster states through “fusion measurements”^[32]. Photonic “gate fidelities” are therefore usually reported conditional on photon detection, a different convention from other platforms^[33].
• Majorana topological qubits. In theory, topologically protected gates are implemented by “braiding” (exchanging quasiparticles) or by measurement, but braiding yields only some Clifford gates, and universal computation still requires non-topological operations such as magic states^[34]. In June 2026 Microsoft announced Majorana 2, reporting a mean qubit lifetime of about 20 seconds^[35]; however, whether its devices host Majorana zero modes remains disputed^[36,37], and topological protection and topological gate operation have not yet been independently established.

5 How “accurate” are gates? Error sources and how they are measured

Gate error can be loosely understood as “the probability that a gate goes wrong”, with fidelity = 1 − error. Note, however, that there is no single definition of “error rate”: experiments commonly report average gate infidelity, error per gate from randomised benchmarking, leakage rates or circuit-level cross-entropy fidelity, and only numbers with the same definition and protocol can be compared rigorously. A fidelity of 99.9% sounds high, but errors accumulate with circuit depth: with 0.1% error per gate and no error correction, under the simplifying assumption that errors are independent and any single error causes failure, a run of 1,000 gates succeeds with probability of about 0.999¹⁰⁰⁰ ≈ 37%. Useful algorithms require far more operations than this (see the resource estimates in Section 6), so one must either push physical gates to extreme accuracy or, more realistically, use quantum error correction to combine many physical gates into one more reliable logical gate^[40].

Where do errors come from? There are five main types: (1) decoherence: the quantum state gradually loses information through interaction with its environment, which matters more for slower gates and shorter coherence times; (2) control errors: small deviations in pulse amplitude, frequency or duration cause “over- or under-rotation”, and such coherent errors can add up over repeated operations; (3) leakage and loss: the qubit leaves the |0⟩/|1⟩ computational space, for example when a transmon is excited to a higher level, while a neutral atom may be lost altogether; when a loss can be detected and its location is known, it is called an “erasure error”, which is easier to correct than an error at an unknown location; (4) crosstalk: an operation on one qubit unintentionally affects neighbouring qubits, especially when many qubits run simultaneously; (5) state preparation and measurement (SPAM) errors: strictly not gate errors, but they affect how gate errors are measured.

How are gate errors measured? Measuring a single gate directly is difficult, because preparation and measurement are themselves imperfect. The field has therefore developed a series of benchmarking methods (Table 3). The most widely used is randomised benchmarking (RB): random sequences of Clifford gates of increasing length are applied, followed by one “undo” gate that should return the system to its initial state, and the decay of the success probability with sequence length gives the average error per gate. In the standard model, SPAM errors mainly shift the starting point of the curve, and the decay rate itself is robust to them^[41,42].

The easiest trap when reading numbers is the reporting convention. The same phrase “two-qubit gate fidelity” may mean the best value for a single pair or the average over all pairs on a chip; isolated operation or all gates running simultaneously (crosstalk raises errors in simultaneous operation); and with or without events such as atom loss or undetected photons removed. For example, a 2026 Harvard preprint reports a CZ fidelity of 99.854%, rising to 99.941% after postselecting on atom loss^[24]; Google explicitly states that Willow's errors are averages measured with gates running simultaneously^[14]. Figure 3 brings representative published results together and separates these conventions.

Figure 3 Representative published gate errors on each platform, not directly comparable across platforms, split into two panels by reporting convention (log scale; further left is better). Panel A shows averages over multi-qubit systems (including simultaneous operation); panel B shows best values for single ions, single pairs or small prototypes; each point is labelled with its metric type. Circles are single-qubit gates, squares two-qubit gates; * marks preprints. The metric definitions (average error per Clifford gate, average gate infidelity, with or without atom-loss postselection, etc.) are not identical, so the figure should not be used to rank platforms; no universal error-correction threshold is drawn, because thresholds depend on the noise model, decoder and other factors. Data: ^{[14–16,19,20,23,24,28,39,43]}.

Table 3 Common methods for benchmarking gate errors

Speed matters too. Superconducting gates take tens of nanoseconds, trapped-ion two-qubit gates typically tens to hundreds of microseconds, and neutral-atom CZ gates a few hundred nanoseconds, though atom rearrangement and measurement are slower. “Highest fidelity” therefore does not mean “fastest computation”: an algorithm's actual runtime depends on the length of a full error-correction cycle and the rate of logical operations. Willow's surface-code cycle, for example, is about 1.1 microseconds^[14].

6 From physical to logical gates: the true cost of fault tolerance

Even physical gate errors of 10⁻⁴ are far from sufficient for algorithms that require hundreds of millions of non-Clifford operations or more (see the resource estimates below). Quantum error correction encodes one logical qubit in many physical qubits; correspondingly, a “logical gate” is a gate operation performed on the encoded state, built from many physical gates while errors are continuously detected and corrected during execution. Figure 4 shows this layered structure.

Figure 4 The layered structure from physical gates to algorithms. In the physical layer, control pulses implement native gates; in the error-correction layer, many physical qubits encode a logical qubit, Clifford logical gates are implemented with transversal gates or lattice surgery, and non-Clifford gates (such as T) in surface-code architectures usually consume high-quality magic states obtained by distillation or “cultivation”; in the algorithm layer, cost is usually measured in T or Toffoli gates.

Clifford logical gates are relatively cheap. One approach is the transversal gate: a logical gate that acts independently across corresponding physical qubits (within one code block, or pairwise between blocks), so that a single physical fault cannot spread to multiple qubits within the same block; this makes the gate naturally fault-tolerant. Another is lattice surgery: merging and splitting neighbouring surface-code “patches” to implement operations such as a logical CNOT^[47]. But the Eastin–Knill theorem proves that no error-correcting code can implement a universal gate set using unitary transversal gates alone^[48]; something is always missing. The two-dimensional surface code lacks a transversal T gate, while certain three-dimensional colour codes, such as the [[15,1,3]] code, admit a transversal T gate but do not provide the full universal set transversally. The restriction can be circumvented with logical measurement and teleportation, which a Harvard-led team used to implement T gates with such three-dimensional codes^[49].

T gates in mainstream architectures: magic states. In mainstream fault-tolerant architectures based on the two-dimensional surface code, a special ancilla state, a magic state, is usually prepared first and then consumed through “gate teleportation”, which is equivalent to applying a T gate. Noisy magic states can be purified by magic-state distillation: for example, 15 noisy magic states are filtered to output one higher-quality magic state^[50]. Because distillation is costly, a Google team proposed the more resource-efficient magic-state cultivation^[51].

Experimental progress since 2024 (mostly at small code distance; several results are preprints):

• Large logical circuits and distance scaling. In 2024 Harvard/MIT/QuEra showed on neutral atoms that a transversal logical CNOT improves as surface-code distance grows from 3 to 7 (with non-fault-tolerant state preparation beyond d = 3), and ran error-detected sampling circuits on up to 48 logical qubits encoded in three-dimensional [[8,3,2]] codes, with 228 logical two-qubit gates and 48 logical controlled-controlled-Z (CCZ) gates^[52].
• Logical Clifford operations and lattice surgery. In 2025 the Harvard-led team demonstrated key elements of a fault-tolerant architecture including transversal gates and lattice surgery^[49]. In 2026 two Chinese superconducting teams posted preprints on distance-3 surface-code lattice surgery: a Zhejiang University team prepared a logical Bell state^[53], and a University of Science and Technology of China (USTC) team composed a logical CNOT, H and S gates without postselection^[54].
• Logical non-Clifford gates and magic states. On Quantinuum's 20-qubit trapped-ion H1-1, a [[6,2,2]] error-detecting code was used to prepare logical magic states (infidelity about 7×10⁻⁵, discarding about 15% of runs) and, from them, a logical controlled-Hadamard gate with infidelity of at most 2.3×10⁻⁴, better than the 10⁻³ of the corresponding physical gate^[55]. A neutral-atom team demonstrated magic-state distillation at the logical level^[56]. Google demonstrated magic-state cultivation on a superconducting processor: the error fell by a factor of about 40 to a state fidelity of 0.9999, but only about 8% of attempts were retained^[57]. The Zhejiang University team used magic-state injection to implement a logical R_X(π/4) rotation with fidelity 0.943, conditional on no detected errors^[53].

The significance of this progress is that several key building blocks required by mainstream fault-tolerant architectures, including protected Clifford operations, lattice surgery, magic-state preparation and purification, and logical non-Clifford operations, have each been demonstrated experimentally. A clear gap to practical use remains: these demonstrations are spread across different platforms and experiments and have not yet been combined into a scalable universal fault-tolerant gate set on a single system; most recent universal or lattice-surgery gate demonstrations still operate at distance 2–3, although a transversal logical CNOT has been shown to improve up to surface-code distance 7; systematic improvement with distance has not yet been shown broadly under fully fault-tolerant state preparation, repeated error correction and non-postselected operation; and several results are still preprints. Resource estimates make the engineering target at the gate level concrete: assuming about 0.1% physical gate error, factoring a 2048-bit Rivest–Shamir–Adleman (RSA-2048) key requires fewer than one million physical qubits and about a week of runtime^[58], and solving 256-bit elliptic-curve discrete logarithms (the basis of Bitcoin and Ethereum signatures) requires fewer than 1,200 logical qubits and fewer than 90 million Toffoli gates^[59]. If each Toffoli gate is decomposed into 4–7 T gates, this corresponds to consuming hundreds of millions of T-state resources at a sufficiently low logical error rate; actual costs depend on the arithmetic circuits and fault-tolerant implementation chosen, and some architectures consume CCZ states directly. This is why the efficiency of magic-state preparation has become a central bottleneck.

7 Conclusions and watch list for 2026–2027

Quantum logic gates are the interface between quantum physics and quantum algorithms. At the physical layer, leading superconducting, trapped-ion and neutral-atom experiments have brought representative two-qubit gate errors into the 10⁻³–10⁻² range under specific benchmarks, with some isolated or prototype systems reaching the 10⁻⁴ level; but the gap between “best single pair” and system-wide operation, and the engineering trade-offs between gate duration and fidelity, mean that no platform leads on every dimension. At the logical layer, the competition is shifting from “can a given logical gate be implemented?” to “can it be implemented reliably, at larger code distance and acceptable overhead?”. Signals worth watching over the next 12–18 months include:

• System-level metrics: whether systems with more than 100 qubits can keep the average two-qubit gate error below 5×10⁻⁴, measured as a system-wide or multi-zone average under each platform's native parallel-operation protocol (a benchmark chosen for this report, set against currently published system-level averages: Helios 7.9×10⁻⁴ across its operation zones, Willow 3.3×10⁻³ with all gates running simultaneously), while also reporting leakage and crosstalk.
• Logical gates improving with code distance: whether logical CNOT and logical non-Clifford gate errors fall systematically with code distance under fully fault-tolerant state preparation and repeated rounds of error correction, without relying on postselection.
• Yield and cost of magic states: acceptance rates of magic-state cultivation and distillation and the space-time overhead per magic state, which will directly determine the runtime of Shor-type algorithms.
• Standardised reporting: whether the field converges on common disclosure conventions (“average, simultaneous operation, with or without postselection, leakage included or not”) that make external comparison possible.

References

[1] Nielsen, M. A. & Chuang, I. L. Quantum Computation and Quantum Information, 10th anniversary edn. Cambridge University Press (2010). https://doi.org/10.1017/CBO9780511976667

[2] Deutsch, D. Quantum computational networks. Proc. R. Soc. Lond. A 425, 73–90 (1989). https://doi.org/10.1098/rspa.1989.0099

[3] Wootters, W. K. & Zurek, W. H. A single quantum cannot be cloned. Nature 299, 802–803 (1982). https://doi.org/10.1038/299802a0

[4] Gottesman, D. The Heisenberg representation of quantum computers. arXiv:quant-ph/9807006 (1998). https://arxiv.org/abs/quant-ph/9807006

[5] Barenco, A. et al. Elementary gates for quantum computation. Phys. Rev. A 52, 3457 (1995). https://doi.org/10.1103/PhysRevA.52.3457

[6] DiVincenzo, D. P. Two-bit gates are universal for quantum computation. Phys. Rev. A 51, 1015 (1995). https://doi.org/10.1103/PhysRevA.51.1015

[7] Bremner, M. J. et al. Practical scheme for quantum computation with any two-qubit entangling gate. Phys. Rev. Lett. 89, 247902 (2002). https://doi.org/10.1103/PhysRevLett.89.247902

[8] Dawson, C. M. & Nielsen, M. A. The Solovay–Kitaev algorithm. Quantum Inf. Comput. 6, 81–95 (2006); arXiv:quant-ph/0505030. https://arxiv.org/abs/quant-ph/0505030

[9] Ross, N. J. & Selinger, P. Optimal ancilla-free Clifford+T approximation of z-rotations. Quantum Inf. Comput. 16, 901–953 (2016); arXiv:1403.2975. https://arxiv.org/abs/1403.2975

[10] Jones, C. Low-overhead constructions for the fault-tolerant Toffoli gate. Phys. Rev. A 87, 022328 (2013). https://doi.org/10.1103/PhysRevA.87.022328

[11] Motzoi, F., Gambetta, J. M., Rebentrost, P. & Wilhelm, F. K. Simple pulses for elimination of leakage in weakly nonlinear qubits. Phys. Rev. Lett. 103, 110501 (2009). https://doi.org/10.1103/PhysRevLett.103.110501

[12] Yan, F. et al. Tunable coupling scheme for implementing high-fidelity two-qubit gates. Phys. Rev. Applied 10, 054062 (2018). https://doi.org/10.1103/PhysRevApplied.10.054062

[13] Rigetti, C. & Devoret, M. Fully microwave-tunable universal gates in superconducting qubits with linear couplings and fixed transition frequencies. Phys. Rev. B 81, 134507 (2010). https://doi.org/10.1103/PhysRevB.81.134507

[14] Google Quantum AI. Willow spec sheet. 9 Dec 2024. https://quantumai.google/static/site-assets/downloads/willow-spec-sheet.pdf

[15] Ding, L. et al. High-fidelity, frequency-flexible two-qubit fluxonium gates with a transmon coupler. Phys. Rev. X 13, 031035 (2023). https://doi.org/10.1103/PhysRevX.13.031035

[16] Smith, M. C. et al. Single-qubit gates with errors at the 10⁻⁷ level. Phys. Rev. Lett. 134, 230601 (2025). https://doi.org/10.1103/42w2-6ccy

[17] Sørensen, A. & Mølmer, K. Quantum computation with ions in thermal motion. Phys. Rev. Lett. 82, 1971 (1999). https://doi.org/10.1103/PhysRevLett.82.1971

[18] Quantinuum. Native parameterized angle hardware gates (Quantinuum Systems documentation). Accessed Oct 2026. https://docs.quantinuum.com/systems/trainings/h2/getting_started/parameterized_angle_2_qubit_gates.html

[19] Ransford, A. et al. A 98-qubit trapped-ion quantum computer with all-to-all connectivity. Nature 655, 81–86 (2026). https://doi.org/10.1038/s41586-026-10676-4

[20] Hughes, A. C. et al. Trapped-ion two-qubit gates with >99.99% fidelity without ground-state cooling. arXiv:2510.17286 (2025). https://arxiv.org/abs/2510.17286

[21] Jaksch, D. et al. Fast quantum gates for neutral atoms. Phys. Rev. Lett. 85, 2208 (2000). https://doi.org/10.1103/PhysRevLett.85.2208

[22] Levine, H. et al. Parallel implementation of high-fidelity multiqubit gates with neutral atoms. Phys. Rev. Lett. 123, 170503 (2019). https://doi.org/10.1103/PhysRevLett.123.170503

[23] Evered, S. J. et al. High-fidelity parallel entangling gates on a neutral-atom quantum computer. Nature 622, 268–272 (2023). https://doi.org/10.1038/s41586-023-06481-y

[24] Evered, S. J. et al. High-fidelity entangling gates and nonlocal circuits with neutral atoms. arXiv:2604.25987 (2026). https://arxiv.org/abs/2604.25987

[25] Loss, D. & DiVincenzo, D. P. Quantum computation with quantum dots. Phys. Rev. A 57, 120 (1998). https://doi.org/10.1103/PhysRevA.57.120

[26] Veldhorst, M. et al. A two-qubit logic gate in silicon. Nature 526, 410–414 (2015). https://doi.org/10.1038/nature15263

[27] Vorreiter, I. et al. Precision high-speed quantum logic with holes on a natural silicon foundry platform. Nat. Commun. 17, 10273 (2026). https://doi.org/10.1038/s41467-026-76231-x

[28] Xue, X. et al. Quantum logic with spin qubits crossing the surface code threshold. Nature 601, 343–347 (2022). https://doi.org/10.1038/s41586-021-04273-w

[29] Noiri, A. et al. Fast universal quantum gate above the fault-tolerance threshold in silicon. Nature 601, 338–342 (2022). https://doi.org/10.1038/s41586-021-04182-y

[30] Steinacker, P. et al. Industry-compatible silicon spin-qubit unit cells exceeding 99% fidelity. Nature 646, 81–87 (2025). https://doi.org/10.1038/s41586-025-09531-9

[31] Knill, E., Laflamme, R. & Milburn, G. J. A scheme for efficient quantum computation with linear optics. Nature 409, 46–52 (2001). https://doi.org/10.1038/35051009

[32] Bartolucci, S. et al. Fusion-based quantum computation. Nat. Commun. 14, 912 (2023). https://doi.org/10.1038/s41467-023-36493-1

[33] PsiQuantum Team (Alexander, K. et al.). A manufacturable platform for photonic quantum computing. Nature 641, 876–883 (2025). https://doi.org/10.1038/s41586-025-08820-7

[34] Nayak, C. et al. Non-Abelian anyons and topological quantum computation. Rev. Mod. Phys. 80, 1083 (2008). https://doi.org/10.1103/RevModPhys.80.1083

[35] Microsoft. Introducing Majorana 2. Microsoft Source, 2 Jun 2026. https://news.microsoft.com/source/features/innovation/majorana-2-microsoft-discovery-agentic-ai/

[36] Microsoft Azure Quantum. Interferometric single-shot parity measurement in InAs–Al hybrid devices. Nature 638, 651–655 (2025). https://doi.org/10.1038/s41586-024-08445-2

[37] Legg, H. F. On the robustness of topological gap detection via transport. Nature 654, E22–E26 (2026); Microsoft Azure Quantum. Reply. Nature (2026). https://doi.org/10.1038/s41586-026-10567-8

[38] Cirac, J. I. & Zoller, P. Quantum computations with cold trapped ions. Phys. Rev. Lett. 74, 4091 (1995). https://doi.org/10.1103/PhysRevLett.74.4091

[39] Löschnauer, C. M. et al. Scalable, high-fidelity all-electronic control of trapped-ion qubits. PRX Quantum 6, 040313 (2025). https://doi.org/10.1103/h4wk-v31j

[40] Fowler, A. G., Mariantoni, M., Martinis, J. M. & Cleland, A. N. Surface codes: towards practical large-scale quantum computation. Phys. Rev. A 86, 032324 (2012). https://doi.org/10.1103/PhysRevA.86.032324

[41] Knill, E. et al. Randomized benchmarking of quantum gates. Phys. Rev. A 77, 012307 (2008). https://doi.org/10.1103/PhysRevA.77.012307

[42] Magesan, E., Gambetta, J. M. & Emerson, J. Scalable and robust randomized benchmarking of quantum processes. Phys. Rev. Lett. 106, 180504 (2011). https://doi.org/10.1103/PhysRevLett.106.180504

[43] Gao, D. et al. Establishing a new benchmark in quantum computational advantage with 105-qubit Zuchongzhi 3.0 processor. Phys. Rev. Lett. 134, 090601 (2025). https://doi.org/10.1103/PhysRevLett.134.090601

[44] Arute, F. et al. Quantum supremacy using a programmable superconducting processor. Nature 574, 505–510 (2019). https://doi.org/10.1038/s41586-019-1666-5

[45] Blume-Kohout, R. et al. Demonstration of qubit operations below a rigorous fault tolerance threshold with gate set tomography. Nat. Commun. 8, 14485 (2017). https://doi.org/10.1038/ncomms14485

[46] Erhard, A. et al. Characterizing large-scale quantum computers via cycle benchmarking. Nat. Commun. 10, 5347 (2019). https://doi.org/10.1038/s41467-019-13068-7

[47] Horsman, C., Fowler, A. G., Devitt, S. & Van Meter, R. Surface code quantum computing by lattice surgery. New J. Phys. 14, 123011 (2012). https://doi.org/10.1088/1367-2630/14/12/123011

[48] Eastin, B. & Knill, E. Restrictions on transversal encoded quantum gate sets. Phys. Rev. Lett. 102, 110502 (2009). https://doi.org/10.1103/PhysRevLett.102.110502

[49] Bluvstein, D. et al. A fault-tolerant neutral-atom architecture for universal quantum computation. Nature 649, 39–46 (2026). https://doi.org/10.1038/s41586-025-09848-5

[50] Bravyi, S. & Kitaev, A. Universal quantum computation with ideal Clifford gates and noisy ancillas. Phys. Rev. A 71, 022316 (2005). https://doi.org/10.1103/PhysRevA.71.022316

[51] Gidney, C., Shutty, N. & Jones, C. Magic state cultivation: growing T states as cheap as CNOT gates. arXiv:2409.17595 (2024). https://arxiv.org/abs/2409.17595

[52] Bluvstein, D. et al. Logical quantum processor based on reconfigurable atom arrays. Nature 626, 58–65 (2024). https://doi.org/10.1038/s41586-023-06927-3

[53] Wang, Y. et al. A superconducting surface-code processor with lattice-surgery logical operations. arXiv:2606.06598 (2026). https://arxiv.org/abs/2606.06598

[54] Lin, W. et al. Surface code logical operations on a superconducting quantum processor. arXiv:2607.01473 (2026). https://arxiv.org/abs/2607.01473

[55] Dasu, S. et al. Breaking even with magic: demonstration of a high-fidelity logical non-Clifford gate. arXiv:2506.14688 (2025). https://arxiv.org/abs/2506.14688

[56] Sales Rodriguez, P. et al. Experimental demonstration of logical magic state distillation. Nature 645, 620–625 (2025). https://doi.org/10.1038/s41586-025-09367-3

[57] Rosenfeld, E. et al. Magic state cultivation on a superconducting quantum processor. arXiv:2512.13908 (2025). https://arxiv.org/abs/2512.13908

[58] Gidney, C. How to factor 2048 bit RSA integers with less than a million noisy qubits. arXiv:2505.15917 (2025). https://arxiv.org/abs/2505.15917

[59] Babbush, R. et al. Securing elliptic curve cryptocurrencies against quantum vulnerabilities: resource estimates and mitigations. PRX Quantum 7, 031001 (2026). https://doi.org/10.1103/j3xf-bw18