The Three-Qubit Bit-Flip Code
as a Quantum-Computing Noise Check of the 13D Geometry
How three qubits protect one bit against a flip — the standard way, and from the geometry-reduced framework
the gentlest check in the series: a sanity test that the framework is ordinary quantum mechanics
A mostly non-technical note for anyone who loves quantum physics — written to be checked by specialists
Chris Bergstrom · physics.magflowmeters.com
Before we start
This note checks whether the thirteen-dimensional quantum framework reproduces the simplest fact in quantum error correction: one qubit is fragile, but three qubits can protect one logical bit against a single bit-flip. We compute the result the standard way, then show it following from the thirteen-dimensional route. The goal is deliberately small — reproduce the elementary error-correction law before claiming anything about large-scale fault tolerance.
Two honest words first, and they cut harder here than anywhere else in the series. This is the most automatic check of the set: the three-qubit code result follows from ordinary finite-dimensional quantum mechanics with no geometric input at all, so the real question is only whether the framework reduces to ordinary quantum mechanics — which, being a quantum theory, it must. And one thing this note is emphatically not: it is not a validation of the corpus’s actual quantum-error-correction work (a specific, separately-simulated architecture); the generic textbook code checked here neither supports nor depends on that. You can read every word skipping every equation.
1. Where this check fits, and why the three-qubit bit-flip code
This note is a coda to the force series — the same ‘two routes, one result’ move, now applied to noise in a quantum computer rather than a force. The three-qubit bit-flip code is the simplest possible error-correction calculation, which is exactly why it is the right first check. It avoids everything hard — arbitrary quantum errors, surface codes, thresholds, magic-state distillation, hardware-specific noise, thousands of logical qubits — and tests one exact idea: can the framework reproduce the standard improvement from a physical error rate p to a logical failure rate 3p²−2p³?
The setup is the simplest in quantum information. A logical qubit α|0⟩ + β|1⟩ is encoded by triplicating each basis state, |0⟩ → |000⟩ and |1⟩ → |111⟩, so the encoded state is α|000⟩ + β|111⟩. The noise is independent bit-flip noise: each physical qubit, with probability p, has its two states swapped by the Pauli operator X. The question is whether the encoded qubit survives a single flip — and the answer, in standard quantum information, is yes.
2. Route one: the bit-flip code in standard quantum information
In the standard route, the code works by majority vote done quantum-mechanically. If one physical qubit flips — say the first, X₁ — the encoded state becomes α|100⟩ + β|011⟩.
Figure 1. The three-qubit bit-flip code in action. Encode, suffer one flip, read the parity syndrome to locate the flipped qubit without touching the logical bit, then correct it. The encoded superposition is restored.
The trick is to find out which qubit flipped without measuring the logical bit — which would collapse the superposition. That is what the stabilizers do: S₁ = Z₁Z₂ and S₂ = Z₂Z₃ are parity checks comparing neighboring qubits. Measuring them gives a two-bit ‘syndrome’ that points to the flipped qubit and nothing else:
Error | Z₁Z₂ | Z₂Z₃ | Correction |
|---|---|---|---|
none | +1 | +1 | none |
X₁ | −1 | +1 | apply X₁ |
X₂ | −1 | −1 | apply X₂ |
X₃ | +1 | −1 | apply X₃ |
The crucial point — the reason the quantum state α|000⟩ + β|111⟩ survives — is that the syndrome reveals which qubit flipped, never whether the logical bit was 0 or 1. Reading the syndrome, applying the matching X to flip the bad qubit back, restores the encoded state. It is the quantum version of majority vote, done without ever looking at the vote’s outcome.
3. The payoff, and its honest size
Now the arithmetic, which is just counting. The physical qubits flip independently with probability p. The code succeeds if zero or one flips, and fails only if two or three flip (because then majority vote points the wrong way). The failure probability is
P_fail = 3p²(1−p) + p³ = 3p² − 2p³,
which for small p is about 3p² — second order in p, where the unencoded qubit fails at first order, p. That is the whole win: encoding converts a first-order error into a second-order one.
Figure 2. What encoding buys, and where it stops. For small p the encoded failure rate 3p²−2p³ sits well below the unencoded rate p. But the two cross at the break-even p = 0.5: above it, three noisy qubits fail more often than one, and encoding hurts.
The figure shows the honest shape of that win, and it is worth dwelling on. The code only helps when p is already small — below the break-even point p = 0.5, where the two curves cross. For p above 0.5, encoding makes things worse: three noisy qubits fail more often than one. Error correction is not magic; it is a trade that pays off only once the physical error rate is low enough. This is the elementary shadow of the ‘threshold’ idea that governs real fault tolerance — though the genuine threshold story, for arbitrary errors and concatenated or surface codes, is far beyond this note.
4. Route two: the same result from the 13D quantum framework
Now the same result from the thirteen-dimensional route — and here honesty requires being plain about how little the geometry has to do. The three-qubit code is built entirely from ordinary, finite-dimensional quantum mechanics: a two-state system (the qubit), superposition, the Pauli operators, a tensor product for independent qubits, parity measurements, and a classically-conditioned correction. None of it refers to the geometry.
So the ‘thirteen-dimensional route’ is simply the observation that the framework, being a quantum theory, must reduce at the operational level to exactly this ordinary quantum mechanics: the same qubit Hilbert space, the same bit-flip channel ρ ↦ (1−p)ρ + pXρX (the coarse-grained effect of a local disturbance coupling the two qubit states), the same stabilizer observables, and the same recovery map.
Figure 3. Two routes, one logical error rate. The match is real — but it is the match of a generic quantum-mechanical result, not a fingerprint of the geometry. Any framework that reduces to ordinary qubit quantum mechanics reproduces it.
Once those are the same — and for any sound quantum theory they are — the logical failure rate is the same, 3p²−2p³. There is no separate number for the geometry to get right here; there is only the requirement that the framework not break ordinary quantum mechanics. That makes this the gentlest check in the series: not a derivation of anything geometry-specific, but a confirmation that the quantum framework is, at the operational level, ordinary quantum mechanics.
5. The two routes meet
Ingredient by ingredient, the two routes use the same objects:
Ingredient | Standard quantum information | 13D quantum framework |
|---|---|---|
Physical system | qubit Hilbert space | reduced two-state sector (ordinary QM) |
Encoding | α|000⟩ + β|111⟩ | same code subspace |
Noise | bit-flip CPTP channel | coarse-grained disturbance → same channel |
Error operator | Pauli X_i | same effective operator |
Syndrome | stabilizers Z₁Z₂, Z₂Z₃ | same parity observables |
Correction | apply X_i from the syndrome | same recovery map |
Failure condition | two or three flips | same |
Result | P_L = 3p² − 2p³ | same |
The two routes meet at the same quantum channel and the same recovery map. Once those are identical — as they are for any framework that reduces to ordinary finite-dimensional quantum mechanics — the logical error rate is identical. The matching is real, but it is the matching of a generic result, not a fingerprint of the geometry.
6. What this does, and does not, show
This is the section that keeps the check in its place, and it carries two warnings rather than one.
What it shows: the thirteen-dimensional quantum framework does not fail the simplest error-correction test. If it reduces to ordinary qubit Hilbert spaces and standard CPTP noise — which a sound quantum theory must — the three-qubit code gives the same logical error rate as ordinary quantum information.
What it does not show: it does not prove fault-tolerant quantum computing; it does not derive a physical qubit platform; it does not handle arbitrary quantum errors (only bit flips); it does not establish a surface-code threshold; and it does not compute any hardware overhead. The honest content is narrow — the framework supports textbook error correction, demonstrated on the simplest code, because it contains ordinary quantum mechanics.
And one separation that must be stated outright, because it is the easiest mistake a reader could make: this elementary check is not, and must not be read as, support for the corpus’s actual quantum-error-correction work. The corpus does carry a quantum-computing result — the same K₆ = SU(3)/T² coset reused as the ‘admissibility chamber’ of a specific error-correction architecture that has been designed and simulated — but that is a separate engineering bridge, carried explicitly at simulated grade, walled off from the physics, feeding no number back into any force claim, and reporting its own honest hardware overhead. The generic three-qubit code checked here is unrelated to that architecture: reproducing 3p²−2p³ neither validates the simulated design nor depends on it. Two different things, kept apart on purpose.
7. The seam, now closed (and how little it took)
As with the companion notes, the step from the framework to the standard result is written out in Appendix A — though here the step is unusually short, because the destination is ordinary quantum mechanics. In one breath: encode α|0⟩ + β|1⟩ as α|000⟩ + β|111⟩; let each qubit flip with probability p; measure the parities Z₁Z₂ and Z₂Z₃ to find the flipped qubit without touching the logical bit; correct it; and the logical failure rate is 3p²−2p³.
What this note completes is the textbook calculation; what it asks of the framework is only that it reduce to ordinary finite-dimensional quantum mechanics, which Appendix A states as a short checklist. The honest reading is the gentlest in the series: a sound quantum framework passes this check automatically, and passing it is a sanity check on quantum-mechanical soundness — not evidence for the geometry, and, to say it once more, not evidence for the corpus’s separately-simulated error-correction architecture.
Appendix A — The full chain, from encoding to the logical failure rate
This appendix writes out the calculation summarized in Section 7, and ends with the short list of operational ingredients the framework must supply. The whole derivation lives inside ordinary finite-dimensional quantum mechanics; nothing here uses the geometry.
A.1 Encoding and the code space
A logical qubit is encoded by triplication; the two logical basis states are the all-zeros and all-ones strings, spanning the two-dimensional code subspace:
A.2 The bit-flip noise channel
Each physical qubit is hit by an independent bit-flip channel — a completely positive, trace-preserving (CPTP) map; the three-qubit noise is the tensor product:
A.3 Stabilizers and the syndrome
A single bit-flip takes the code state out of the code space in a way the parity checks detect. The stabilizers are two-qubit parity operators; the syndrome projectors sort the Hilbert space by their ±1 eigenvalues:
The four syndromes (+,+), (−,+), (−,−), (+,−) map one-to-one to the four single-qubit cases none, X₁, X₂, X₃ (the table in Section 2) — and, crucially, none of them reveals the logical amplitudes α, β.
A.4 The logical failure rate
The code corrects zero or one flip and fails on two or three; counting the independent-flip probabilities gives the standard quadratic suppression:
A.5 The recovery map
Recovery measures the syndrome and applies the matching Pauli correction — a CPTP map; the corrected encoded channel is the composition of noise then recovery:
A.6 The general structure: codes, noise, and Knill–Laflamme
The same pattern is the general theory of quantum error correction: a code subspace inside a tensor-product Hilbert space, a noise channel in Kraus form, and a recovery channel:
A code corrects an error set exactly when the Knill–Laflamme conditions hold; for the bit-flip code the correctable set is the identity and the three single-qubit flips:
A.7 What the framework must supply, and what rests where
The only obligation on the thirteen-dimensional framework is that it reduce, at the operational level, to ordinary finite-dimensional quantum mechanics — stated as a checklist so nothing is assumed silently:
- qubit Hilbert subspaces and tensor-product composition for independent qubits;
- the Pauli operators as effective controls/errors, and unitary gates;
- projective or POVM measurement, and environmental coarse-graining to CPTP noise channels;
- stabilizer/parity measurements and recovery maps with classical feed-forward;
- no hidden nonlinearity or non-unitarity that would break the standard error-correction structure.
- What the corpus establishes. Nothing geometry-specific is needed for this result; it follows from ordinary quantum mechanics, which any sound quantum framework contains at the operational level.
- What is explicitly separate. The corpus’s own quantum-error-correction result — the K₆ = SU(3)/T² coset as the admissibility chamber of a designed-and-simulated architecture (Paper II §16) — is carried at simulated grade, walled off from the physics, and is neither supported by nor depended on by this elementary code.
Closed result. Given that the thirteen-dimensional quantum framework reduces, at the operational level, to ordinary finite-dimensional quantum mechanics, the three-qubit bit-flip code gives the same syndrome table and the same logical failure rate P_fail = 3p² − 2p³ as standard quantum information. This is a minimal quantum-mechanical soundness check, conditional only on that reduction — not a proof of fault-tolerant quantum computing, and not evidence for the corpus’s separately-simulated error-correction architecture.
Notes and sources
[1] The three-qubit bit-flip code, the stabilizers Z₁Z₂ and Z₂Z₃, the syndrome table, the logical failure rate 3p²−2p³, and the Knill–Laflamme conditions are standard quantum information; see any quantum-computing text (e.g. Nielsen & Chuang, Quantum Computation and Quantum Information).
[2] This note checks only that the framework reduces to ordinary finite-dimensional quantum mechanics; the result carries no geometric input and is the most automatic check in this series.
[3] The corpus’s own quantum-error-correction result — the K₆ = SU(3)/T² coset reused as the admissibility chamber of a designed-and-simulated error-correction architecture — is in the source corpus, Paper II (‘Forces’), §16, carried explicitly at SIMULATED grade as an external engineering bridge that feeds no number back into any force-interface claim, with its own reported physical-to-logical overhead. The generic code in this note is unrelated to that architecture and neither supports nor depends on it: physics.magflowmeters.com/articles/Forces.html
[4] Companion notes: the five force and quantum-gravity consistency notes — The Sun as a Lens, Hydrogen, Muon Decay, The Color-Coulomb Potential, Single-Graviton Exchange — and the synthesis, One Geometry, Four Forces.