1. The short version, what to know first, and where this fits in the series

• Why error correction is needed: even the best qubit operations fail about 0.1% of the time (10⁻³). A small number for one operation, but after 1,000 operations the chance of no error at all falls to about 37%. Long computations need a way to find and fix errors Sourced [Ref. 12] Our calculation
• Qubits can be corrected anyway: a qubit cannot be copied and measuring it disturbs it. But if we measure only a symptom (syndrome), such as "is this the same as its neighbour?", we can locate an error without disturbing the information. The information is not copied; it is spread over several qubits Sourced [Ref. 1, 2, 4]
• The surface code and its threshold: the surface code arranges this idea on a two-dimensional lattice. If the physical error rate is below the threshold, a bigger lattice suppresses logical errors exponentially. Google showed that each increase of the lattice size (code distance) from 3 to 5 to 7 cut errors by about 2.14 times Sourced [Ref. 12]

2. Why error correction is needed — error rates and the length of a computation

(1) An everyday example: "10,000 steps without one mistake"

Suppose you add numbers on a calculator 10,000 times in a row, and each button press has a 0.1% chance of being wrong. Each step is 99.9% reliable, which sounds high. But the chance that all 10,000 steps succeed is 0.999 multiplied by itself 10,000 times, which is about 0.0045% (4.5×10⁻⁵) Our calculation. "Each step rarely fails" and "a long job finishes without failure" are different statements.

(2) A quantum computation has a great many operations

A quantum computation stacks up millions or hundreds of millions of quantum gates (single operations on qubits; see the series explainer "Quantum Gates and Quantum Circuits"). Google's paper says the best many-qubit machines have only recently reached 99.9% accuracy for two-qubit gates (0.1% error), while many applications need error rates below 10⁻¹⁰ Sourced [Ref. 12]. The gap between what is needed and what exists is seven orders of magnitude (0.1% = 10⁻³ versus 10⁻¹⁰; our calculation).

Our calculation. Probability of success = (1−p)^N. A simple calculation assuming independent errors, not the success rate of any real computation. As a rule of thumb, after about 1/p operations, the chance that everything is correct is about 37% (1/e).

3. Starting from classical error correction — a majority vote of three

(1) An everyday example: saying a phone number three times

Suppose you must pass on a number over a bad phone line. Say it three times. Even if one repetition is misheard, the other two agree, and a majority vote gives the right number. This is the idea of a repetition code (the simplest error-correcting code: protect information by keeping it several times over). You protect information by adding more of it (redundancy).

(2) Checking with a small calculation

Let p be the probability that one bit flips. With a majority vote of three, the vote fails only when two or more bits flip together. That probability is 3p²(1−p) + p³ = 3p² − 2p³ (assuming independence; our calculation). For p = 10% (0.1) it is 2.8%; for p = 1% it is 0.0298%. The smaller p is, the faster the benefit of redundancy grows. Conversely, if p is near 0.5, no number of copies helps.

4. Why quantum is harder — three walls and how to get over them

"Keep three copies and vote" cannot be used directly on qubits. There are three walls. We look at each one, and at how it is overcome.

No-cloning is from Wootters and Zurek and from Dieks [Ref. 6, 7]; the general theory of error correction is from the textbook and reviews [Ref. 1, 2, 8]. The plain-language "how it is overcome" column is our commentary.

Let us check how to read the figure. A qubit's state is an arrow from the sphere's centre. A bit flip swaps north and south (an arrow leaning to 0 now leans to 1). A phase flip swaps left and right. After a phase flip, the odds of measuring 0 or 1 do not change. It is an error that measuring cannot reveal, yet it upsets the later "strengthening and cancelling of waves" (interference) in the computation. Quantum error correction has to handle both kinds.

5. The three-qubit code, step by step

First, the smallest quantum error-correcting code, aimed at bit flips only. It is a standard textbook example [Ref. 1, 2, 3]. We use three qubits, q₁, q₂ and q₃. The information to protect starts in q₁.

Step 1: Encode — not copying, but "linking"

q₂ and q₃ start at 0. Using q₁ as the "control", apply a CNOT (controlled-NOT: flip the target only when the control is 1) to each of q₂ and q₃. If q₁ was α|0⟩ + β|1⟩, the result is α|000⟩ + β|111⟩: a state where the component "all three are 0" carries α and "all three are 1" carries β.

Let us use real numbers. Take α = 0.6 and β = 0.8 (the odds of 0 and 1 are 0.6² = 0.36 and 0.8² = 0.64; squares add up to 1 by convention). The encoded state is 0.6|000⟩ + 0.8|111⟩ (an example for Our calculation). Measure the three qubits separately and you always get "000" (probability 0.36) or "111" (probability 0.64), so the three always agree. That is what "three qubits behave as one block" means.

Step 2: An error occurs

Now suppose a bit flip hits q₂. The state becomes 0.6|010⟩ + 0.8|101⟩. Only q₂ disagrees with the other two.

Step 3: Check the symptom — measure "same as its neighbour?", not the value

We use helper qubits a₁ and a₂. a₁ checks only "do q₁ and q₂ have the same value?" and a₂ checks "do q₂ and q₃ have the same value?" (two CNOT gates each, then measure the helper). Each answer is "same (0)" or "different (1)". The pair of answers (a₁, a₂) is called the syndrome (the symptom).

In the example, q₁ differs from q₂, so a₁ = 1; q₂ differs from q₃, so a₂ = 1; the symptom is (1, 1). Here is the key point. The symptom is the same for the "000" component and the "111" component (after the error, "010" and "101" both give (1, 1)). So measuring the symptom reveals nothing about the ratio 0.6 : 0.8 (the protected information) and does not disturb it. We measured only "which neighbours disagree", not "is it 0 or 1 right now".

Step 4: Correct

The symptom fixes the location of the error (see the figure above). (1, 0) means q₁ flipped, (1, 1) means q₂, (0, 1) means q₃; (0, 0) means no error. We have found q₂, so flipping q₂ again restores 0.6|000⟩ + 0.8|111⟩. The information was never "measured" at any point.

The limit of this code

The three-qubit code can fix bit flips only, and it actually makes phase flips worse. A phase flip on any one of q₁, q₂ or q₃ changes the protected information (the sign in α|000⟩ + β|111⟩). If a phase flip happens with probability q on each qubit, the chance that the protected information is spoiled by a phase flip is about 3q (three qubits at q each; an approximation for small q; Our calculation).

The remedy is a code of the same structure for phase flips (used in a changed basis), nested with the bit-flip code. That is the nine-qubit code Shor presented in 1995 [Ref. 4]. The next year Steane showed a code that does the same job with seven qubits [Ref. 5]. Both protect one logical qubit with several physical qubits and fix any single-qubit error Sourced [Ref. 4, 5].

6. Stabilizers and syndrome measurement — generalising the small example

The "same as its neighbour?" check of the last section is called, in general, a stabilizer. It means "a check that always gives the same answer (+1) on the protected state". When an error occurs, the answer becomes −1 and the error is noticed. Defining a code by a set of checks (stabilizer codes) was systematised by Gottesman [Ref. 8].

[[n,k,d]] is the standard way to state a code's size (n physical qubits, k logical qubits, distance d). The Shor and Steane values are from the original papers [Ref. 4, 5]; the surface code from the descriptions in the Google and AlphaQubit papers [Ref. 12, 18]. The "what the checks are" column is our commentary.

What is "distance"?

The code distance d is a number telling how many errors must pile up before they become an undetectable error (a logical error). If d errors link up, the checks no longer see them. Fewer than d errors are always noticed. Up to (d−1)/2 errors can be fixed correctly (one for d = 3, two for d = 5, three for d = 7). The "majority vote of three" of Section 3 was a distance-3 example (it fixes up to one error).

7. How the surface code works — lattice, checks and lit points

(1) Arranging qubits on a lattice

The surface code is an error-correcting code that places qubits on a two-dimensional lattice. It descends from the toric code Kitaev devised in the late 1990s [Ref. 9]; Bravyi and Kitaev gave a planar version with edges [Ref. 10], and Dennis and colleagues analysed the recovery procedure and the "threshold" [Ref. 11]. The review by Fowler and colleagues tied it to the design of large computers [Ref. 14].

In the figure, the circles are data qubits (they hold the information) and the squares are measure qubits (qubits used only for the checks). For distance d there are d² data qubits and d²−1 measure qubits, 2d²−1 in all Sourced [Ref. 12]. That is 17 for d = 3, 49 for d = 5 and 97 for d = 7 Our calculation. The square at the centre of a blue tile (X check) checks whether the "phase" of the four surrounding data qubits agrees; the square at the centre of an orange tile (Z check) checks whether their "values" agree, every cycle.

(2) Where does the logical qubit's information live?

The protected information is not in any one data qubit; it is spread over the whole lattice. Look at any single qubit and you learn nothing (the "entanglement" point of Section 4). The "logical operations" that read and write the information correspond to chains of length d running from edge to edge (the dotted vertical and horizontal lines in the figure) [Ref. 18]. If d errors link up and reach edge to edge, it becomes an undetectable logical error. That is why distance is the "thickness of the protection".

(3) Errors "light up" neighbouring checks

When an error occurs, the answers of the neighbouring checks disagree. Such a disagreement is called a detection event (a check's answer differing from the previous cycle) [Ref. 18]. In the figure, disagreeing checks are drawn red as "lit". A single error lights up two neighbouring checks (or one at an edge). If several errors form a chain, only the checks at the two ends of the chain light up; those in between cancel each other.

(4) Why a two-dimensional lattice with neighbour-only checks?

In the surface code, each check looks at only four neighbouring qubits. No direct wiring between distant qubits is needed. You only have to lay qubits out on a flat chip and couple neighbours, so it is well suited to implementation in superconducting qubits and similar devices. Wang and colleagues showed a procedure that, with only nearest-neighbour interactions on a 2D square lattice, tolerates gate errors even above 1% Sourced [Ref. 15].

There is a cost. For each piece of protected information you need d² data qubits, and 2d²−1 qubits including measure qubits. New codes that reduce this size (the overhead) are covered in the next article, "Logical Qubits and Fault-Tolerant Quantum Computing".

8. Decoders — working out what happened from the lit points

A decoder is a classical computer (or the processing it performs) that takes the check results (the pattern of lit points), infers "which qubits suffered errors", and decides the correction. Because the answer is sometimes not unique, it picks "the most likely error". Fewer errors are more likely, so the basic principle is "the inference that uses the fewest errors".

(1) Minimum-weight perfect matching (MWPM)

Join the lit points in pairs (or to an edge) so that the total length of the paths (the number of errors) is shortest. Correct the qubits along the paths. In panel B (two errors) of the previous figure, joining the two lit points by the shortest path agrees with the real errors. This is the most widely used decoder for the surface code [Ref. 16].

(2) Measurements can be wrong too — look along time as well

The checks themselves can also err. So rather than a single measurement, you line up the results of several cycles and look at "what changed since the previous cycle" (detection events). This makes it a three-dimensional problem: the 2D lattice plus a time axis. Dennis and colleagues formulated this approach [Ref. 11].

The kinds and performance of decoders depend on the code, the noise assumptions and the implementation (software or dedicated circuits). Do not line the numbers up to rank the methods.

9. The threshold — "below the line, bigger is better"

(1) A thicker defence also adds things to defend

Enlarging the surface code lattice thickens the protection. But it also adds places where errors can happen (qubits and operations). Which wins? Google's paper puts the balance this way: if the physical error rate is below the threshold, adding qubits suppresses logical errors exponentially; above it, adding qubits makes things worse Sourced [Ref. 12]. In theory, Preskill explains that if the error rate per gate is below a critical value, an arbitrarily long computation can be carried out with reliable accuracy Sourced [Ref. 13].

(2) The formula, and a numerical example

Google's paper approximates the logical error rate ε_d of the surface code, using the physical error rate p and the threshold p_th, as follows Sourced [Ref. 12].

ε_d ∝ (p / p_th)^(d+1)/2 The reduction per two steps of distance: Λ = ε_d / ε_d+2 ≈ p_th / p

In words: "if p is half the threshold, each increase of distance by two cuts logical errors by about half". Λ (lambda) is the number telling by what factor logical errors fall when the distance goes up by two. As a numerical example, for p/p_th = 0.5 (Λ = 2) and a proportionality constant of 1, you get 0.25 at distance 3, 0.125 at distance 5, 0.0625 at distance 7 and 0.03125 at distance 9 Our calculation. Each step of distance halves the error.

(3) Numbers from Google's experiment (announced 2024, published in Nature 2025)

Google ran surface codes of distance 3, 5 and 7 on superconducting qubits (a 105-qubit chip) and measured the logical error rates. The table below uses values from the paper's supplementary table (neural-network decoder, offline) Sourced [Ref. 12].

The "ratio to the previous distance" column is 6.50 ÷ 3.03 = 2.15 and 3.03 ÷ 1.43 = 2.12 (Our calculation). The paper averages several placements per distance and reports Λ = 2.14 ± 0.02 from a least-squares fit [Ref. 12]. Even with the same data, Λ depends on the decoder (an ensemble of matching decoders gives Λ = 2.04 ± 0.02 and ε₇ = 0.171%).

In this experiment, the lifetime of the distance-7 logical qubit was 291 ± 6 microseconds, 2.4 ± 0.3 times that of the best constituent physical qubit (119 ± 13 microseconds) [Ref. 12]. This is described as passing "break-even" (the point where a logical qubit outlasts the best physical qubit). But the paper itself notes that this measure does not include the cost of state preparation, measurement or gates [Ref. 12]. "Lasting a long time as memory" and "being able to compute" are different things.

What happens if we extend this result? Google's paper estimates by extrapolation that reaching a logical error rate of 10⁻⁶ would take distance 27 (1457 physical qubits) [Ref. 12]. Our simple calculation (assuming Λ = 2.14 stays unchanged as distance grows) gives 7.1×10⁻⁷ at distance 27, the same conclusion Our calculation. If the physical error rate halved and Λ roughly doubled (to 4.28), distance 17 (577 physical qubits) would reach 10⁻⁶ Our calculation. That is about 2.5 times fewer qubits (1457 ÷ 577), which leads into the materials discussion in Section 11.

10. How far experiments have come (as of 16 October 2026)

Experiments on the "memory" side of error correction (keeping qubit information alive), with the surface code and others, have advanced greatly in recent years. The table lists the main peer-reviewed papers we could confirm. The platforms, codes and ways of measuring differ, so do not line the numbers up to rank them.

Each number is as stated in the abstract or text of the paper concerned (notation kept as in the original). Experiments we could not confirm (for example distance-7-or-larger experiments on other superconducting machines) are not included.

11. Remaining walls, and a materials engineer's view

(1) What remains

• Computation (logical gates): so far we have discussed "memory". To compute while keeping the code intact, more techniques (lattice surgery, magic states and so on) are needed. They are covered in "Logical Qubits and Fault-Tolerant Quantum Computing" in this series
• Leakage: errors where a qubit ends up outside the "0 and 1" states. Google's distance-7 experiment uses four extra qubits to remove leakage [Ref. 12] Sourced
• Correlated errors: errors that strike many nearby qubits at once. They break the assumption behind majority voting (that errors are independent). Google's paper says even a distance-29 repetition code levelled off at 10⁻¹⁰, with correlated errors about once an hour as the cause [Ref. 12] Sourced
• Scale: distance 27 for a logical error of 10⁻⁶ means 1457 physical qubits (above). Applications that need many logical qubits push this up by further orders of magnitude (next article)
• Speed and wiring: measurement every 1.1 microseconds, the decoder, and thousands of wires and their cooling ("Cryogenics and Control" in this series)

12. What could not be confirmed, and a summary

What could not be confirmed

• The text of ISO/IEC 4879:2024: it is paid, so we confirmed only the title, month of publication and status, and do not describe the definitions.
• The publication status of IEEE P7131: we checked the working group's site, but could not tell from that page whether the standard has been published.
• Below-threshold experiments at distance 7 or more on other superconducting machines: the peer-reviewed experiments we could confirm are limited to those in the table. Other work may be under way.
• Independent verification of IBM's "real-time decoding in under 480 nanoseconds": we checked IBM's announcement and the method's preprint [Ref. 19, 20] but could not confirm independent verification (company claim).
• A measured value of the theoretical threshold on real machines: experiments are reported through Λ (the change as distance grows); we did not confirm the threshold value itself.

13. How to read evaluations and standards

The progress of quantum error correction is mainly measured by these "yardsticks": the logical error rate (how much the protected information is damaged per cycle), the error-suppression factor Λ (by what factor errors fall as distance grows), break-even (whether the protected information outlasts the best physical qubit), and decoder latency (whether it keeps up with the cycle). None of them has a meaning unless you state the kind of code, the distance, the number of cycles, the decoder and how the average was taken. As for standards, we could not confirm one that directly defines how to evaluate error correction; a terminology standard is the stage that has been published. Check date: 16 October 2026.

The arrangement of the table is Our calculation (organising). Numbers, titles and publication months of standards were checked on each body's page (check date 16 October 2026). Standards texts are paid, so only titles and scope are given.

Cautions in reading (for materials engineers)

• "Logical qubit" means different things for different codes, distances and ranges of measurement: read an announcement that "a logical qubit was made" together with which code, what distance, what logical error rate and how many cycles were measured. "Below threshold" and "error suppression" also need "compared with what, by what factor"
• Company announcements and peer review or independent verification are different: the experiments in the table are peer-reviewed papers. Items resting only on company announcements, such as decoder speed, are treated as "company claims"
• Memory and computation are different: most of the experiments in the table keep a logical qubit alive. The error rate of a computation including logical gates must be checked separately
• Standards are still at the terminology stage: ISO/IEC 4879 is a terminology standard and has no legal force or power to decide pass or fail on performance (in general a standard becomes binding when cited in law or a contract; our commentary). The benchmarking standard (IEEE P7131) was a draft as of the check date

14. Glossary

15. References

1. Nielsen M. A., Chuang I. L. Quantum Computation and Quantum Information, 10th anniversary edition, Cambridge University Press (2010) (the standard textbook reference for error correction) — doi.org/10.1017/CBO9780511976667
2. Roffe J. "Quantum error correction: an introductory guide", Contemporary Physics 60, 226–245 (2019), DOI 10.1080/00107514.2019.1667078 — arxiv.org/abs/1907.11157
3. Devitt S. J., Munro W. J., Nemoto K. "Quantum error correction for beginners", Rep. Prog. Phys. 76, 076001 (2013), DOI 10.1088/0034-4885/76/7/076001 — arxiv.org/abs/0905.2794
4. Shor P. W. "Scheme for reducing decoherence in quantum computer memory", Phys. Rev. A 52, R2493 (1995), DOI 10.1103/PhysRevA.52.R2493 — doi.org/10.1103/PhysRevA.52.R2493
5. Steane A. M. "Error correcting codes in quantum theory", Phys. Rev. Lett. 77, 793 (1996), DOI 10.1103/PhysRevLett.77.793 — doi.org/10.1103/PhysRevLett.77.793
6. Wootters W. K., Zurek W. H. "A single quantum cannot be cloned", Nature 299, 802–803 (1982), DOI 10.1038/299802a0 — doi.org/10.1038/299802a0
7. Dieks D. "Communication by EPR devices", Phys. Lett. A 92, 271–272 (1982), DOI 10.1016/0375-9601(82)90084-6 — doi.org/10.1016/0375-9601(82)90084-6
8. Gottesman D. "Stabilizer codes and quantum error correction", PhD thesis, arXiv:quant-ph/9705052 (1997) — arxiv.org/abs/quant-ph/9705052
9. Kitaev A. Yu. "Fault-tolerant quantum computation by anyons", Ann. Phys. 303, 2–30 (2003), DOI 10.1016/S0003-4916(02)00018-0 — doi.org/10.1016/S0003-4916(02)00018-0
10. Bravyi S. B., Kitaev A. Yu. "Quantum codes on a lattice with boundary", arXiv:quant-ph/9811052 (1998) — arxiv.org/abs/quant-ph/9811052
11. Dennis E., Kitaev A., Landahl A., Preskill J. "Topological quantum memory", J. Math. Phys. 43, 4452–4505 (2002), DOI 10.1063/1.1499754 — doi.org/10.1063/1.1499754
12. Google Quantum AI and Collaborators "Quantum error correction below the surface code threshold", Nature 638, 920–926 (2025), DOI 10.1038/s41586-024-08449-y (arXiv:2408.13687) — doi.org/10.1038/s41586-024-08449-y
13. Preskill J. "Reliable quantum computers", Proc. R. Soc. Lond. A 454, 385–410 (1998), DOI 10.1098/rspa.1998.0167 — doi.org/10.1098/rspa.1998.0167
14. 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), DOI 10.1103/PhysRevA.86.032324 — doi.org/10.1103/PhysRevA.86.032324
15. Wang D. S., Fowler A. G., Hollenberg L. C. L. "Surface code quantum computing with error rates over 1%", Phys. Rev. A 83, 020302(R) (2011), DOI 10.1103/PhysRevA.83.020302 — doi.org/10.1103/PhysRevA.83.020302
16. Higgott O., Gidney C. "Sparse Blossom: correcting a million errors per core second with minimum-weight matching", Quantum 9, 1600 (2025), DOI 10.22331/q-2025-01-20-1600 — doi.org/10.22331/q-2025-01-20-1600
17. Delfosse N., Nickerson N. H. "Almost-linear time decoding algorithm for topological codes", Quantum 5, 595 (2021), DOI 10.22331/q-2021-12-02-595 — doi.org/10.22331/q-2021-12-02-595
18. Bausch J. et al. "Learning high-accuracy error decoding for quantum processors", Nature 635, 834–840 (2024), DOI 10.1038/s41586-024-08148-8 — doi.org/10.1038/s41586-024-08148-8
19. Müller T. et al. (IBM) "Improved belief propagation is sufficient for real-time decoding of quantum memory", arXiv:2506.01779 (2025) (preprint) — arxiv.org/abs/2506.01779
20. IBM "IBM Delivers New Quantum Processors, Software, and Algorithm Breakthroughs on Path to Advantage and Fault Tolerance", press release (12 November 2025) (company announcement) — newsroom.ibm.com (2025-11-12)
21. Google Quantum AI "Suppressing quantum errors by scaling a surface code logical qubit", Nature 614, 676–681 (2023), DOI 10.1038/s41586-022-05434-1 — doi.org/10.1038/s41586-022-05434-1
22. Bluvstein D. et al. "A fault-tolerant neutral-atom architecture for universal quantum computation", Nature 649, 39–46 (2025), DOI 10.1038/s41586-025-09848-5 — doi.org/10.1038/s41586-025-09848-5
23. Lacroix N. et al. "Scaling and logic in the colour code on a superconducting quantum processor", Nature 645, 614–619 (2025), DOI 10.1038/s41586-025-09061-4 — doi.org/10.1038/s41586-025-09061-4
24. Putterman H. et al. (AWS) "Hardware-efficient quantum error correction via concatenated bosonic qubits", Nature 638, 927–934 (2025), DOI 10.1038/s41586-025-08642-7 — doi.org/10.1038/s41586-025-08642-7
25. McEwen M. et al. "Resisting high-energy impact events through gap engineering in superconducting qubit arrays", Phys. Rev. Lett. 133, 240601 (2024), DOI 10.1103/PhysRevLett.133.240601 — doi.org/10.1103/PhysRevLett.133.240601
26. Vepsäläinen A. P. et al. "Impact of ionizing radiation on superconducting qubit coherence", Nature 584, 551–556 (2020), DOI 10.1038/s41586-020-2619-8 — doi.org/10.1038/s41586-020-2619-8
27. Cardani L. et al. "Reducing the impact of radioactivity on quantum circuits in a deep-underground facility", Nat. Commun. 12, 2733 (2021), DOI 10.1038/s41467-021-23032-z — doi.org/10.1038/s41467-021-23032-z
28. ISO/IEC 4879:2024 "Information technology — Quantum computing — Vocabulary" (published May 2024). Number, title, date and "Published" status were checked on the listing page of the Institute for Standardization of Serbia (ISS) — iss.rs/en/project/show/iso:proj:80432 (the official ISO page is https://www.iso.org/standard/80432.html; it could not be fetched automatically from our environment, and was confirmed through search-result listings)
29. IEEE P7131 working group "Quantum Benchmarking Working Group P7131" (site of the working group on the draft standard for quantum computing performance metrics and benchmarking) — sagroups.ieee.org/7131

16. Claim-to-source audit

Last updated 16 October 2026. Sources are limited to primary material (peer-reviewed papers, arXiv papers, a textbook, company announcements and ISO standard listing pages). Company announcements are marked as company claims. Numerical estimates are our own calculations and not results from real machines. The text of ISO/IEC 4879, the publication status of IEEE P7131, independent verification of IBM's decoding speed, and a measured value of the threshold on real machines could not be confirmed and are not stated here. All figures are explanatory concept diagrams or drawings that include our calculations; Fig. 1 and Fig. 10 are ImageGen-generated conceptual illustrations.