Abstract
The errors that can enter a qubit form a continuum. Why can a code with finitely many correctable errors fix them? This paper asks who does the discretising: the answer is the measurement, not the code. No new mathematical theorem and no new law is claimed.
First, we count the errors on one qubit. $E=c_0I+c_1X+c_2Y+c_3Z$ has $\mathbf{8}$ real parameters and is a continuum (Section 2).
Second, this is the core of the paper. The measurement projects that onto the $\mathbf{4}$ outcomes $I,X,Y,Z$: the discretising is done by the measurement, not the code (Section 2).
Third, fixing $X$ and $Z$ fixes $Y$. Since $Y=iXZ$, only $2$ kinds need independent correction (Section 3).
Fourth, a code covers only a sliver. Of the $4^9=\mathbf{262144}$ Pauli operators on $9$ qubits, distance $3$ fixes $\mathbf{28}$, a fraction of $\mathbf{1.068\times10^{-4}}$ (Section 4).
Fifth, in the surface code, $3.24$ times gives one hundredth. From $d=5$ to $9$, physical qubits $25\to81$ and logical error rate $10^{-3}\to10^{-5}$ (Section 5).
Sixth, the separator is whether a projection is needed. Classical codes need none, because their errors are discrete to begin with (Section 6).
Scope (what is not claimed)
No new mathematical theorem and no new law is claimed: error discretisation, the Pauli basis, stabiliser codes, surface codes, and the threshold theorem are all standard. We do not construct codes: all we count is numbers of parameters and numbers of errors. We do not prove the threshold theorem: the value $p_{th}\approx10^{-2}$ is quoted as a number only. We do not derive the logical error rate: $(p/p_{th})^{(d+1)/2}$ is an asymptotic estimate that drops constant factors. The values of Section 5 are orders, not predictions. We do not discuss surface-code implementation: lattice geometry, measurement circuits, and decoders are not treated at all. The count $\approx d^2$ physical qubits is the simplest estimate. We do not treat correlated errors: the count of Section 4 assumes independent single-qubit errors. With correlations, errors leave the weight-$1$ bracket. We do not read $1.068\times10^{-4}$ pessimistically. It is a fraction of all Pauli operators, not a fraction of the errors that actually occur. If real errors concentrate at weight $1$, then $28$ suffices in practice. This paper does not assert which is the case. On the sibling paper: Paper 281 treats the same quantum error correction and counts that the syndrome tells $8$ bits about the error and $0$ bits about the state: the root is the same (measurement does not destroy the state) but the question differs. That paper asks what the measurement does not take; this one asks what the measurement makes discrete. Readers are advised to read them side by side. Relation to earlier papers: Paper 163 separated “a good code exists” from “here is a good code”. This paper counts what a constructed code actually covers. Paper 179 showed that “cannot be constructed” has distinct roots: the impossibility of $d=4$ here likewise has counting as its root. Paper 252 counted four quantities called “information”. This paper separates continuous parameters from discrete outcomes. Paper 269 showed that what a crystal forbids is periodicity: the discretisation here is likewise imposed by a structure. What is added is counting a one-qubit error as $8$ real parameters falling to $4$ outcomes after measurement, computing that distance $3$ covers $28$ of $4^9=262144$, a fraction of $1.068\times10^{-4}$, confirming that $3.24$ times in the surface code corresponds to one hundredth, and placing the difference from the classical case at “whether a projection is required”.
1. Notation and the Question
Setting: An error on one qubit is a $2\times2$ matrix $E$. In the Pauli basis,
$$E=c_0 I+c_1 X+c_2 Y+c_3 Z$$Question: The $c_i$ vary continuously. Why can a code that fixes only finitely many errors nevertheless correct them?
Observation 1.1 The common explanation is that “the code discretises the errors.”This paper regards that as imprecise. What discretises is the measurement.
2. The Core: Eight Real Parameters Fall to Four Outcomes
Check 2.1: We count the error’s degrees of freedom before and after measurement.
| Kind of error | Count / dimension | |
|---|---|---|
| Before | $c_0I+c_1X+c_2Y+c_3Z$ | $\mathbf{8}$ real parameters (continuum) |
| After | $I$ or $X$ or $Y$ or $Z$ | $\mathbf{4}$ outcomes (discrete) |
Observation 2.2 This is the core of the paper. The code discretises nothing: the syndrome measurement projects the state onto one of four branches. What remains afterwards is a single Pauli error, and it suffices to undo it.
Observation 2.3 So “a continuum becomes discrete” is the work of the measurement. The same projection appeared in Paper 281 in the form of taking $0$ bits about the state: one and the same measurement performing two offices.
Check 2.4: We extend to $n$ qubits.
| $n$ | Pauli operators $4^n$ | Real parameters before, $2\cdot4^n$ |
|---|---|---|
| $1$ | $4$ | $8$ |
| $5$ | $1024$ | $2048$ |
| $7$ | $16384$ | $32768$ |
| $9$ | $\mathbf{262144}$ | $524288$ |
Observation 2.5 Even at $n=9$, what remains after measurement is $\mathbf{262144}$ discrete errors. A $524288$-dimensional continuum has fallen to a finite set: that fall alone makes correction possible.
3. Fixing $X$ and $Z$ Fixes $Y$
Observation 3.1 The Pauli matrices satisfy $Y=iXZ$. So a code that fixes $X$-type and $Z$-type errors separately fixes $Y$-type automatically: two kinds, not three, need fixing.
Observation 3.2 Shor’s $9$-qubit code has exactly this shape. Phase flips ($Z$) are fixed across blocks of three, bit flips ($X$) within a block: the $3\times3$ structure exists to handle the two kinds separately.
Observation 3.3 Here is where it differs from classical coding. Classically there is only one kind of error, the bit flip, because there is no phase degree of freedom.
Check 3.4: We compare the number of errors to fix at the same distance.
| Code | $n$ | Kinds of error | Errors to correct |
|---|---|---|---|
| Classical Hamming $[7,4,3]$ | $7$ | bit flip only | $1+n=\mathbf{8}$ |
| Quantum $[[7,1,3]]$ (Steane) | $7$ | $X$, $Y$, $Z$ | $1+3n=\mathbf{22}$ |
| Ratio | $\mathbf{2.75}$ |
Observation 3.5 At the same $n=7$ and the same distance $3$, the quantum code must cover $\mathbf{2.75}$ times as many errors. It still achieves $k=1$: a quarter of the classical $k=4$ in embedded information.
4. A Code Covers Only $1.068\times10^{-4}$
Setting: A distance-$d$ code fixes Pauli errors of weight at most $t=\lfloor(d-1)/2\rfloor$. Their number is $\sum_{k=0}^{t}\binom{n}{k}3^k$.
Check 4.1:
| $d$ | $t$ | Physical qubits $n$ | Errors fixed | Fraction of $4^n$ |
|---|---|---|---|---|
| $3$ | $1$ | $9$ | $\mathbf{28}$ | $\mathbf{1.068\times10^{-4}}$ |
| $5$ | $2$ | $25$ | $2776$ | $2.466\times10^{-12}$ |
| $7$ | $3$ | $49$ | $508180$ | $1.604\times10^{-24}$ |
| $9$ | $4$ | $81$ | $137095984$ | $2.345\times10^{-41}$ |
Observation 4.2 There are $\mathbf{262144}$ Pauli errors on $9$ qubits, and a distance-$3$ code fixes only $\mathbf{28}$. The fraction is $\mathbf{1.068\times10^{-4}}$: a code cannot fix most errors.
Observation 4.3 And enlarging the code drives the fraction down sharply. At $d=9$ it is $2.345\times10^{-41}$: the number fixed grows, yet the share of the whole falls by $10^{37}$.
Observation 4.4 A point to write honestly. This number must not be read pessimistically. It is a fraction of all Pauli operators, not of the errors that actually occur: if physical errors cluster near weight $1$, then $28$ is enough.
Observation 4.5 So what a code presupposes is that errors are sparse. Correlated errors break that assumption: the number $1.068\times10^{-4}$ shows how much that assumption is carrying.
5. The Surface Code: $3.24$ Times for One Hundredth
Setting: The surface code uses about $d^2$ physical qubits and has logical error rate $(p/p_{th})^{(d+1)/2}$. We take $p=10^{-3}$ and $p_{th}=10^{-2}$.
Check 5.1:
| $d$ | Physical qubits $d^2$ | Logical error rate |
|---|---|---|
| $3$ | $9$ | $1.000\times10^{-2}$ |
| $5$ | $25$ | $1.000\times10^{-3}$ |
| $7$ | $49$ | $1.000\times10^{-4}$ |
| $9$ | $81$ | $1.000\times10^{-5}$ |
| $11$ | $121$ | $1.000\times10^{-6}$ |
Check 5.2: We write the price as ratios.
| Change in $d$ | Factor in physical qubits | Factor in logical error rate |
|---|---|---|
| $3\to5$ | $2.7778$ | $1/10$ |
| $\mathbf{5\to9}$ | $\mathbf{3.2400}$ | $\mathbf{1/100}$ |
| $3\to9$ | $9.0000$ | $1/1000$ |
| $9\to11$ | $1.4938$ | $1/10$ |
Observation 5.3 Multiplying the physical qubits by $\mathbf{3.24}$ divides the logical error rate by $\mathbf{100}$. Three times the resource for two decades: a polynomial price for an exponential gain, which is the content of the threshold theorem.
Observation 5.4 But one must have $p<p_{th}$. If $p>p_{th}$ then $(p/p_{th})>1$ and raising $d$ makes things worse: one and the same expression reverses direction across the threshold.
Observation 5.5 A point to write honestly: $(p/p_{th})^{(d+1)/2}$ is an asymptotic form with constants dropped. The values of Section 5 are orders, not predictions for hardware.
6. Separator: Whether a Projection Is Required
Observation 6.1 Separator. What must be moved for the need to discretise to disappear? That the errors be discrete to begin with.
| Space of errors | Discretisation | |
|---|---|---|
| Classical code | $\{0,1\}^n$ (discrete already) | not needed |
| Quantum code | $2^n\times2^n$ matrices (continuum) | projection by measurement needed |
Observation 6.2 Classically an error is whether a bit flipped, with no in-between. Quantum mechanically there are errors in which an amplitude shifts slightly: one cannot fix “shifted slightly,” but once measured it becomes “shifted” or “not shifted”.
Observation 6.3 This resembles the figure of Paper 269. There, the structure of periodicity narrowed the permitted symmetries to a discrete five. Here, the operation of measurement narrows a continuum of errors to a discrete four. In neither case is it the object itself doing the narrowing.
Observation 6.4 Paper 163 separated “a good code exists” from “here is a good code.”This paper counts, for a constructed code, what it actually covers: $28$ out of $262144$, a number invisible to a proof of existence.
7. Roll Call and Closing
- A one-qubit error has $8$ real parameters (Check 2.1): A continuum.
- After measurement, $4$ outcomes (Check 2.1): The measurement discretises.
- $4^9=262144$ at $n=9$ (Check 2.4): $524288$ dimensions fall to a finite set.
- $Y=iXZ$ (Observation 3.1): Two kinds need independent fixing.
- Classical $8$ against quantum $22$ (Check 3.4): $2.75$ times.
- Distance $3$ fixes $28$ (Check 4.1): $1.068\times10^{-4}$.
- $2.345\times10^{-41}$ at $d=9$ (Check 4.1): The share falls.
- $3.2400$ times from $d=5$ to $9$ (Check 5.2): Logical error rate $1/100$.
- Reversed if $p>p_{th}$ (Observation 5.4): One expression, both directions.
- Classical needs no projection (Observation 6.1): Discrete to begin with.
Closing: The familiar statement that “continuous errors get discretised” is right. But what discretises is the measurement, not the code. A one-qubit error has $\mathbf{8}$ real parameters and forms a continuum, yet the syndrome measurement projects it onto the $\mathbf{4}$ outcomes $I,X,Y,Z$. What remains is a single Pauli error, and undoing it suffices. Since $Y=iXZ$, only $2$ kinds need independent correction. Meanwhile the reach of a code is narrow: of the $\mathbf{262144}$ Pauli errors on $9$ qubits, distance $3$ fixes $\mathbf{28}$, a mere $\mathbf{1.068\times10^{-4}}$. It works because the assumption that errors are sparse is doing the work. And the price is polynomial: multiplying the physical qubits by $\mathbf{3.24}$ divides the logical error rate by $\mathbf{100}$. One thing separates them: whether the errors are discrete to begin with, or a projection is required. A classical code needs no projection. In a quantum code, measuring is a precondition of correcting, and the separate fact that measuring does not destroy the state is what makes it possible.
Revision Record
Second edition (October 2026): the dashes used as separators in the text were replaced by punctuation; section headings containing mathematics, which had been cut off in display, were repaired; no claim, number or reference was changed.
References
- Shor, P. W. (1995). Scheme for Reducing Decoherence in Quantum Computer Memory. Physical Review A, 52(4).
- Steane, A. M. (1996). Error Correcting Codes in Quantum Theory. Physical Review Letters, 77(5).
- Knill, E. and Laflamme, R. (1997). Theory of Quantum Error-Correcting Codes. Physical Review A, 55(2).
- Kitaev, A. Y. (2003). Fault-Tolerant Quantum Computation by Anyons. Annals of Physics, 303(1).
- Fowler, A. G., Mariantoni, M., Martinis, J. M. and Cleland, A. N. (2012). Surface Codes: Towards Practical Large-Scale Quantum Computation. Physical Review A, 86(3).
- Aharonov, D. and Ben-Or, M. (1997). Fault-Tolerant Quantum Computation with Constant Error. In Proceedings of the 29th Annual ACM Symposium on Theory of Computing.
- Nielsen, M. A. and Chuang, I. L. (2010). Quantum Computation and Quantum Information. Cambridge: Cambridge University Press.
- Yamagishi, Y. (2026). “A Good Code Exists” and “Here Is a Good Code” Are Different Sentences [Paper 163]. Zenodo. 10.5281/zenodo.22092677
- Yamagishi, Y. (2026). It Cannot Be Copied, Yet It Can Be Corrected [Paper 281]. Zenodo. 10.5281/zenodo.22171058
- Yamagishi, Y. (2026). “Cannot Be Constructed” Has Distinct Roots [Paper 179]. Zenodo. 10.5281/zenodo.22098419
- Yamagishi, Y. (2026). Information Is Four Quantities, and They Need Different Things [Paper 252]. Zenodo. 10.5281/zenodo.22161148
- Yamagishi, Y. (2026). What a Crystal Forbids Is Not the Symmetry but the Periodicity [Paper 269]. Zenodo. 10.5281/zenodo.22169855
Reference
Yamagishi, Y. (2026). What Discretises a Continuum of Errors Is Not the Code but the Measurement [Paper 287]. YOI: https://www.yamagishiyuuki.com/yoi/287
DOI: 10.5281/zenodo.22171265
ORCID: 0009-0006-8587-3450
PDF (English) · PDF (Japanese) · Date proof of the English PDF (OpenTimestamps .ots) · SHA256SUMS
The record page for this paper (in Japanese, with the PDFs in each language and the date proof): YOI 287. This paper is a preprint and has not been peer reviewed.