Part 10: The Machine Itself
Table of Contents
(Updated: July 2026)
This is Part 10 of Quantum Computing for Cybersecurity Professionals, an 11-part series that builds quantum computing from the ground up for security and IT professionals who know classical crypto but have no physics background. No lies-to-children, no hype, every claim checkable with arithmetic. Read the full series online or download the free ebook.
Ten millikelvin. That is the temperature inside the dilution refrigerator holding a superconducting quantum processor, roughly one hundredth of a degree above absolute zero, hundreds of times colder than the cosmic microwave background that fills the rest of the universe. The chip sits behind nested magnetic shields, in high vacuum, its control lines attenuated and filtered at every thermal stage. Enormous engineering effort goes into cutting it off from the world.
Its qubits still forget everything they know in under a hundred microseconds.
That failure, and the two decades of engineering aimed at it, is the central barrier between every threat in this series and a machine that can execute it, though not the only one: scale, control fidelity, connectivity, decoding speed, and a full logical gate set all have to arrive too. Part 8 showed you the algorithm that breaks RSA. This part shows you the hardware that cannot yet run it, why not, and what would have to change. By the end you will know what decoherence actually is (you already have the concept; it has been hiding in this series since Part 2 under a different name), how a machine corrects errors in data it is forbidden to read, and why the qubit count in the headline is almost never the number that decides anything. Which makes this the part that changes how you read the news.
The environment never stops measuring
Recall the strangest result in Part 4. Two devices in series returned certainty from a fair coin, and installing a detector between them killed the effect, whether or not anyone read the detector. Any record of the intermediate value, anywhere, in anything, destroyed the interference. The reversal ran on silence.
Now stop thinking of that detector as laboratory equipment and start thinking of it as the world. A stray photon bounces off your qubit and flies away carrying news of its state. A vibration in the chip’s substrate couples to the qubit’s energy. A wandering magnetic field nudges its phase. A cosmic ray strikes the silicon. Each of these leaves a record of the qubit’s condition somewhere in the environment, which is Part 3‘s definition of a measurement: an interaction that leaves a record, minds optional. Nobody reads these records. Nobody has to. The interference dies anyway, exactly as the which-path test predicted, and the computation dies with it.
That is decoherence, and it now has a precise description in the vocabulary this series built. The environment entangles with your qubit without being invited. Once qubit and photon are correlated, the qubit alone has no amplitude pair of its own, and the delicate signs that were going to cancel wrong answers are smeared into the universe, unrecoverable, because you cannot copy them back and reading what remains only spends it. Part 2 asked you to hold on to the word “recordless.” Here is the invoice. Every millikelvin, every layer of shielding, every filtered control line in that refrigerator is there to buy silence, and the silence is never complete.
WHERE THIS BREAKS: Two analogies, one for the villain, one for the cure.
The environment as adversary. Decoherence behaves like a side-channel attack running continuously against your hardware, and the comparison earns its keep: information leaks into the surroundings through physical couplings nobody designed, and the defense is isolation, shielding, and filtering, exactly as with TEMPEST. Where it breaks: there is no adversary, no intent, and nobody who ever reads the leaked data. The universe is not attacking your computer. It is simply in contact with it, and in quantum mechanics contact is enough. That is worse than an attacker, because you cannot deter it, out-resource it, or wait for it to lose interest.
Integrity without plaintext. Error correction below checks parity relationships without reading the protected data, which will feel like verifying an HMAC without ever seeing the message. Where it breaks: an HMAC check is optional, and reading the message would merely be indiscreet. Here, reading the data is fatal to it, so the parity check has to be engineered so that measuring it cannot possibly disturb what it protects. The constraint is physics, and it dictates the entire architecture.
Correcting errors you are forbidden to look at
Classical error correction is old, understood, and everywhere: parity bits, ECC memory, RAID. All of it rests on two moves this series has already taken away from you. Copy the data, and compare the copies. No-cloning forbids the first. Measurement destruction forbids the second, since looking at a qubit to see whether it drifted is exactly the act that ruins it.
For a while this looked fatal, and serious physicists argued that quantum computing was thermodynamically impossible for precisely this reason. Then in 1995, Peter Shor published a scheme for protecting quantum memory from decoherence, one year after publishing the algorithm that made the machine worth building. The same man broke RSA and then rescued the machine that would do it, which is either a fine joke or a fair description of how small this field was in the nineties.
The trick is to stop asking about values and start asking about relationships. Spread one qubit’s worth of information across several physical qubits in an entangled state, then design a measurement that reveals only whether the qubits still agree with each other, never what they agree on. Agreement is a parity relationship, and parity can be extracted through helper qubits that touch the data without exposing it. The answer that comes back is called a syndrome, and it says something like “qubits one and two disagree, qubits two and three agree,” which pinpoints where an error struck while telling you nothing whatsoever about the encoded state. Correct the flagged qubit and the logical information rides on, having never been read. My syndrome extraction writeup goes deeper for those who want the full machinery.
The bill for this is large. Real codes must catch both bit flips and phase flips (the second is a uniquely quantum failure, a silent inversion of the minus sign that has driven every result in this series), which multiplies the qubit budget. The surface code, today’s workhorse, arranges physical qubits in a lattice and measures parities across neighboring plaquettes continuously, forever, at roughly a million cycles per second, with a classical decoder racing in real time to interpret each syndrome before the next arrives. The machine is not computing most of the time. It is checking itself, relentlessly, and stealing a little computation in the gaps.
THE ARITHMETIC: Finding an error without reading the data.
The simplest code, protecting against bit flips only. Encode one logical qubit into three physical ones, mapping the amplitude on 0 onto the string 000 and the amplitude on 1 onto 111. A qubit in the state $$(a_0, a_1)$$ becomes a three-qubit state with $$a_0$$ on 000 and $$a_1$$ on 111, and nothing anywhere else.
This is not cloning. Three copies of $$(a_0, a_1)$$ would put amplitude on all eight strings, including 010 and 101. This state has amplitude on two strings only, and Part 5‘s failed copier is exactly what built it.
Now flip the middle qubit. The state becomes $$a_0$$ on 010 and $$a_1$$ on 101. Measure two parities, using helper qubits that compute the answer without touching the data:$\text{parity}(q_1, q_2) = 1 \quad \text{(they differ)} \qquad \text{parity}(q_2, q_3) = 1 \quad \text{(they differ)}$
Both checks fire, which happens for exactly one error: a flip on qubit two. Flip it back. Note precisely what you learned. You learned where the error was. You learned nothing about $$a_0$$ or $$a_1$$, because 010 and 101 have the same parity pattern, so the syndrome is identical whichever amplitude the state was carrying. The data stayed sealed. Check the other cases yourself: a flip on qubit one fires the first check only, a flip on qubit three fires the second only, and no error fires nothing.
That is quantum error correction in miniature. Real codes are bigger and catch phase flips too, and the logic is this logic.
Below threshold, and why the argument changed
Here is the objection that kept this field in the wilderness for a decade, and it is a good one. Error correction requires operations, and operations are themselves error-prone. Add more physical qubits and you add more places for things to go wrong. If the correction machinery introduces errors faster than it removes them, then scaling up makes the machine worse, and no amount of engineering rescues it.
The answer is the threshold theorem, and it is the most consequential result in the field after Shor. If the physical error rate per operation is below a critical threshold, then adding redundancy suppresses logical errors exponentially: each increase in code size makes the logical qubit dramatically more reliable. Above threshold, the machinery drowns. Below it, the machinery wins, and it wins faster than the qubit count grows. Everything depends on which side of that line the hardware sits, which is why “below threshold” is the only hardware milestone I consider load-bearing.
In December 2024, Google’s Willow processor crossed it, and the result was published in Nature. Scaling the surface code from distance 5 to distance 7 cut the logical error rate by a factor of 2.14, in the direction the theorem predicts, and the distance-7 logical qubit outlived the best physical qubit on the chip. That headline result used a high-accuracy decoder running offline, after the fact. A separate distance-5 memory on the same processor demonstrated the other half of the problem. Redundancy started paying for itself.
This is where I have to be honest on both fronts at once, because the temptation to spin this result in either direction is enormous. To the denialists, who spent twenty years calling fault tolerance a fantasy: the central scaling prediction is now measured on hardware, adding redundancy lowered the error rate rather than raising it, and that moves the core question from “is this possible” to “how far does it go.” To the panic industry, which read the same paper as a countdown: this was a memory, holding one idle logical qubit alive, not a logical gate, a non-Clifford operation, or a machine that runs an algorithm for days, and all of those remain undemonstrated. One distance-7 logical qubit costs 101 physical qubits, while Shor against RSA-2048 needs a few thousand logical qubits at error rates orders of magnitude below anything shown. Comparing Willow’s memory-error-per-cycle directly against an algorithm’s total gate budget would be comparing unlike quantities, so I won’t put a single number on the gap. It is large on every axis that matters. Neither fact cancels the other; both belong in any honest assessment.
FOR THE RECORD: Willow’s numbers, separated properly.
The Nature paper reports two distinct memories, and coverage that merges them gets the milestone wrong. The distance-7 surface code across 101 physical qubits reached a logical error of 0.143% ± 0.003% per cycle, with error-suppression factor Λ = 2.14 ± 0.02 for each increase of two in code distance, the signature of below-threshold operation, and a logical lifetime 2.4× its best physical qubit. That result was decoded offline. Separately, a distance-5 code held below-threshold performance with an integrated real-time decoder averaging 63 μs latency against a 1.1 μs cycle time, over runs up to a million cycles. High-accuracy scaling came from one code; real-time decoding came from the other.
And the detail most coverage omitted, which Google reported plainly: running repetition codes out to distance 29, performance was limited by rare correlated error events striking roughly once an hour. Cosmic rays and similar bursts hit many qubits at once, which no code designed for independent errors handles gracefully. Fault tolerance at scale has to answer that, and it has not yet. This is what an honest milestone looks like: a real result, with the next problem named in the same paper.
The number in the headline is the wrong number
Which brings us to the distinction that determines what any qubit headline means. A physical qubit is a piece of hardware: a transmon circuit, a trapped ion, an atom in an optical tweezer. A logical qubit is an abstraction woven from many physical ones by error correction, and it is the only unit in which algorithms are written. Shor’s resource estimates are quoted in logical qubits (a few thousand for RSA-2048) and paid for in physical ones, but the conversion is not a fixed rate. Gidney’s 2025 surface-code analysis put RSA-2048 under a million physical qubits; 2026 preprints using qLDPC codes or reconfigurable neutral atoms claim under 100,000, or even 10,000 at the cost of far longer runtimes. The exchange rate is a property of the architecture, not a constant of nature.
So when a vendor announces 1,000 qubits, the professional question is not “is that a lot.” It is: physical or logical, at what error rate, under what code, with what decoder, and sustained for how long. My CRQC Quantum Capability Framework exists precisely because a single number cannot answer that, and tracks the capabilities that actually gate a CRQC: error correction, syndrome extraction, below-threshold scaling, connectivity, logical gate fidelity, magic states, decoder performance, continuous operation, and manufacturability. Qubit count moves none of them.
MYTH AUTOPSY: “They just hit 1,000 qubits, so we must be close.”
The count in the headline is almost always physical, and physical qubits are the cheap part. Today’s machines carry hundreds to a few thousand of them at error rates that make deep circuits impossible; RSA-2048 needs a few thousand logical qubits, each woven from many physical ones under an error-correcting architecture that determines the ratio, running a deep circuit without a fatal error. The headline number and the number that matters are separated by orders of magnitude and a great deal of engineering.
Now the deeper cut, and the one that will keep you sane through the next two years of press releases: “logical qubit” is not a standardized unit. Compare three results published within fifteen months. Google’s Willow spent 101 physical qubits on a single distance-7 surface-code logical qubit, decoded offline. QuEra published 96 logical qubits from 448 physical atoms in Nature in January 2026, using high-rate codes with a far better exchange rate. Quantinuum, on 98 trapped ions, reported up to 94 error-detected logical qubits and 48 error-corrected ones using iceberg codes, and the detection-versus-correction split is a different guarantee entirely: detection tells you an error happened and makes you discard the run, correction fixes it and lets the computation continue.
All three are real. None are commensurable. A logical qubit’s worth depends on its code, its distance, its error rate, and whether it can survive a long algorithm rather than a demonstration. Anyone comparing logical-qubit counts across platforms without stating those parameters is selling something, possibly to themselves.
Say instead: ask which capability moved. Qubit counts are inputs, and the CRQC is gated by error rates, decoder speed, logical gate fidelity, and sustained operation.
Five ways to build a qubit
The modalities differ in ways that matter for reading roadmaps, and each trades the same currencies: speed, fidelity, connectivity, and manufacturability.
Superconducting circuits (Google, IBM, Rigetti) are fast, with gates in tens of nanoseconds, and they are lithographed like chips, which is a real manufacturing advantage. They are also the noisiest, needing dilution refrigerators and dense microwave wiring that becomes its own scaling problem. Trapped ions (Quantinuum, IonQ) are the opposite: exquisite fidelity and all-to-all connectivity, with gate speeds a thousand times slower, which bites hard when Shor needs ten billion sequential operations. Neutral atoms (QuEra, Pasqal, Atom Computing, Infleqtion) have surged, offering thousands of identical atoms held in optical tweezers and physically shuffled to create connectivity, which is exactly what produced QuEra’s high-rate-code result. Photonic approaches (PsiQuantum, Xanadu) run at room temperature and lose photons instead of scrambling them. Silicon spin qubits (Intel, Diraq) are the smallest, betting that the existing semiconductor industry becomes decisive at scale.
Nobody knows which wins. It is entirely possible that more than one does, and equally possible that the winner is a modality nobody is funding today.
ATTACKER’S-EYE VIEW: How to read a quantum press release.
You will be forwarded these announcements by executives asking whether to panic. Six questions, in order, and the machine’s own physics generates all of them.
Physical or logical? Almost always physical; if logical, under which code and at what distance. What is the error rate per operation, and is it below threshold? Does the machine hold below-threshold performance with a real-time decoder, or was decoding done offline afterward, which is a demonstration rather than a computer? For how long does it run: a burst of a few hundred cycles, or hours, since Shor needs days of coherent operation. Is the result error correction or error detection? And the question that dissolves ninety percent of the hype: does this move any capability that a CRQC actually requires, or does it move a number that is easy to grow?
There is also a defensive lesson buried in the hardware. Everything in this part says a quantum computer is a monstrously fragile instrument that any leaked record can ruin, and that fragility will not save you, because the adversary does not need a reliable machine for long. They need one machine, once, for a week, with your ten-year-old harvested traffic in the queue. Fragility delays the threat. It does not defuse it, and it certainly does not shorten your migration.
What to remember
Decoherence is the environment measuring your qubits without being invited, entangling with them and carrying off the signs that were going to cancel wrong answers, which is why the machine lives in a refrigerator colder than deep space and still fails in microseconds. Error correction works despite no-cloning and destructive measurement by checking parity relationships rather than values, so it learns where an error struck while learning nothing about the data it protects. The threshold theorem says that below a critical physical error rate, redundancy suppresses logical errors exponentially, and Google’s Willow demonstrated exactly that in 2024, which moved fault tolerance from physics question to engineering problem while leaving a four-order-of-magnitude gap to a CRQC. Physical qubits are the cheap part and the headline part; logical qubits are the unit that matters, and “logical qubit” is not yet a standardized unit across platforms. Ask which capability moved.
Next, in Part 11, “Reading the Field Like a Professional”: the series closes by turning all of this into working equipment. How to read a vendor roadmap and a research paper, which milestones would actually change your migration timeline, what the resource estimates do and do not tell you, and the standing answers to the questions you will be asked for the rest of your career.
