What a Qubit Actually Is

Over the next twenty-seven posts this series takes one company at a time and works through its qubits from the material up: what physical object holds the information, what you do to it to compute, and how it breaks. The roster runs from superconducting loops of aluminium to single atoms held in beams of light to photons that don’t exist yet.

Before any of that, we need a shared vocabulary. This post builds it. It is the one post in the series with no company in it, and it’s the one every later post will link back to.

A warning about what you’re not going to get. You will not be told that a qubit is “zero and one at the same time,” or that quantum computers “try all answers simultaneously.” Both are false in ways that make everything downstream incomprehensible. The real picture is stranger, and — this is the part that surprises people — considerably more concrete.

Start with the object

A classical bit is a physical thing. In your laptop it’s charge trapped on a capacitor in a DRAM cell, or the magnetization of a patch of a disk. We say “bit” and think of an abstraction, but underneath there is always a piece of matter in one of two distinguishable states.

A qubit is also a physical thing. The difference is that the piece of matter is small enough, cold enough, and isolated enough that quantum mechanics governs its behaviour, and quantum mechanics permits states that “on” and “off” don’t cover.

Here is the crucial move, the one that makes the rest of the series make sense: almost any sufficiently isolated quantum system with two distinguishable energy levels can serve as a qubit. Nature doesn’t provide qubits. It provides electrons, atoms, photons, and circuits, and engineers find two levels in one of them to press into service.

That’s why this series has twenty-seven more posts. The companies have made genuinely different choices about which two levels to use:

• A superconducting circuit — a loop of aluminium on a silicon chip, cooled to twenty millikelvin, where the qubit states are the two lowest energy levels of an electrical oscillator. Human-made, printed by lithography, and roughly the width of a hair.
• A trapped ion — a single atom stripped of one electron, suspended in vacuum by electric fields, where the two states are two configurations of its internal electronic structure. Not manufactured at all. Every barium ion in the universe is identical to every other.
• A neutral atom — a whole atom held in a focused laser beam, using either two internal levels or a ground state versus a hugely inflated “Rydberg” state.
• An electron in silicon — the qubit is which way the electron’s spin points, up or down, in a magnetic field. The smallest option on the list, and the one closest to existing semiconductor manufacturing.
• A photon — a single particle of light, where the two states might be two paths it could take, or two polarizations. Works at room temperature. Presents the opposite problem: photons barely interact with anything, including each other.

These are not variations on a theme. They differ in size by ten orders of magnitude, in operating temperature by four, and in how long they survive by nine. Much of what follows in this series is the consequence of those differences.

Superposition, stated carefully

A classical bit is 0 or 1. A qubit’s state is described by two numbers — call them α and β — one attached to the outcome 0 and one attached to the outcome 1. The state is written

|\psi\rangle = \alpha|0\rangle + \beta|1\rangle

where the bracket notation |0⟩ just means “the state we’ve labelled 0.” Read the whole expression as: this qubit has amplitude α on 0 and amplitude β on 1.

When you measure the qubit, you get a single classical bit — 0 or 1, never anything else. The probability of 0 is |α|², the probability of 1 is |β|². Since one of them must happen, |α|² + |β|² = 1.

Now, if that were the whole story, a qubit would be a coin: a thing with a probability of landing each way. It isn’t, and the reason is that α and β are complex numbers.

That sounds like a technicality. It is the entire subject.

Probabilities are non-negative — they can only accumulate. Amplitudes are complex, so they have a phase, and amplitudes arriving at the same outcome by different routes can cancel. Two possibilities, each individually likely, can combine to produce something that never happens.

This is interference, and you already accept it everywhere else in physics. Two water waves meet crest-to-trough and flatten. Two beams of light overlap and produce dark fringes. Noise- cancelling headphones work by generating exactly the sound that cancels the sound already there. Nobody finds destructive interference of sound mysterious.

Quantum mechanics says the same arithmetic governs possibilities. That’s the whole trick.

So the honest one-sentence description of a quantum algorithm is not “it tries all answers at once.” It is: arrange the computation so that the amplitudes leading to wrong answers cancel, and the amplitudes leading to right answers reinforce, before you look. Designing a quantum algorithm is choreographing an interference pattern. It’s hard, and it’s why we have so few good quantum algorithms rather than a general speedup for everything.

Why it isn’t just randomness

If you’re unconvinced that complex amplitudes buy anything real, here is the experiment that settles it, in the form every quantum engineer meets early.

There’s a single-qubit operation — the Hadamard gate — that takes a definite |0⟩ and produces equal amplitudes on 0 and 1. Apply it once, measure, and you get 0 or 1 with 50/50 odds. It looks exactly like flipping a fair coin.

Now apply it twice with no measurement in between, then measure. If the qubit were really a coin — randomized once, randomized again — you’d still get 50/50. Instead you get 0, with certainty.

The second application undoes the first. The routes leading to outcome 1 arrive with opposite phases and cancel exactly; the routes leading to 0 reinforce. A coin cannot do this. No amount of classical randomness can, because you cannot un-flip a coin by flipping it again.

This is the experiment that tells you the amplitudes are physically real and not just bookkeeping for our ignorance. It’s also, in a very practical sense, the thing every hardware company is fighting to preserve — the entire engineering effort described in this series exists to keep those phases intact long enough to be useful.

Entanglement, stated carefully

With two qubits there are four possible measurement outcomes — 00, 01, 10, 11 — and the state carries an amplitude for each. With three qubits, eight amplitudes. With n qubits, 2ⁿ.

That exponent is what draws people to the field. Describing the state of 300 qubits requires more amplitudes than there are atoms in the observable universe. Nature tracks it effortlessly; your laptop cannot.

Entanglement is what happens when a multi-qubit state cannot be decomposed into a separate description of each qubit. Consider

|\psi\rangle = \tfrac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)

Amplitude on 00, equal amplitude on 11, nothing on 01 or 10. Measure the first qubit: 0 or 1, 50/50. Measure the second: 0 or 1, 50/50. Individually, each looks like noise. But the outcomes always agree. Always. There is no way to write down “what the first qubit is doing” and “what the second qubit is doing” separately — the correlation is the whole content of the state.

Two things are worth being precise about, because popular accounts routinely aren’t:

It doesn’t transmit anything. Measuring your half of an entangled pair produces a random result, whatever your partner does. You cannot signal with it. What entanglement provides is correlation stronger than any classical mechanism can produce — a fact established experimentally, repeatedly, and recognized with the 2022 Nobel Prize in Physics.

It’s not fragile because it’s delicate — it’s fragile because it’s promiscuous. This is the most useful intuition in the whole subject. Entanglement is easy. Your qubit will happily entangle with a stray photon, a vibrating atom in its substrate, a fluctuating charge in the oxide layer nearby. And once it’s entangled with the environment, the environment holds part of the information, the interference pattern is spoiled, and you’re left with an ordinary probabilistic mess.

That process is called decoherence, and understanding it as unwanted entanglement with the surroundings rather than as some vague “fragility” explains nearly every engineering decision you’ll read about in this series. Dilution refrigerators, ultra-high vacuum chambers, magnetic shielding, isotopically purified silicon — none of it is about keeping qubits comfortable. It’s about denying them anything to entangle with.

The catch nobody mentions

Those 2ⁿ amplitudes are real, but you cannot read them out. Measuring n qubits yields n classical bits and destroys everything else. The exponential lives inside the machine; it does not come out.

This is why quantum computers are not simply faster computers, and why “quantum will speed up [your favourite workload]” is usually wrong. The speedups we know about are for specific problems whose structure lets interference concentrate the answer into a few measurable bits — factoring, simulating quantum systems, certain optimization and linear-algebra problems under conditions that are easy to overstate. For most tasks, no such choreography is known, and quantum hardware offers nothing.

What it takes to be a computer

In 2000, David DiVincenzo wrote down what a physical system must provide to run quantum algorithms. Twenty-six years later it remains the checklist every platform in this series is graded against, and it’s worth internalizing because it explains why so many promising physical systems never become computers.

1. Scalable, well-characterized qubits. Not just two levels, but two levels you can identify precisely, in a system you can build many of.
2. Initialization. You must be able to set the qubits to a known state before starting. Sounds trivial; often isn’t.
3. Coherence long enough to compute. Not long in absolute terms — long relative to how long a gate takes. A qubit that lives a microsecond but gates in a nanosecond beats a qubit that lives a second but takes a millisecond per gate.
4. A universal set of gates. Enough distinct operations to compose any computation. Typically: arbitrary single-qubit rotations plus one entangling two-qubit gate.
5. Qubit-specific measurement. You must be able to read out an individual qubit, reliably, without disturbing its neighbours.

Every one of these has killed candidate platforms. Criterion 3 in particular is where most of the drama in this series lives, and it’s worth restating as the ratio it really is:

The figure of merit is coherence time divided by gate time — how many operations you can perform before the qubit forgets.

This single ratio explains an apparent paradox you’ll hit repeatedly. Trapped ions have coherence times measured in seconds — thousands of times better than superconducting circuits, whose qubits live for tens to hundreds of microseconds. Yet the two platforms are competitive, because ion gates take microseconds while superconducting gates take tens of nanoseconds. Slow and long-lived versus fast and short-lived. Ratios, not absolutes. Watch for this in every stat block.

T₁ and T₂

Two numbers describe how a qubit fails, and they appear in every post in this series.

T₁ — energy relaxation. The qubit is in |1⟩, the excited state. Given the chance, it dumps its energy into the environment and decays to |0⟩, exactly as an excited atom emits a photon. T₁ is the characteristic time for that decay. It’s an irreversible loss of energy, and the information goes with it.

T₂ — dephasing. More subtle, and usually the real problem. The qubit keeps its energy, but the phase between its amplitudes drifts. Since the phase is what makes interference work, losing it makes the qubit useless while leaving it apparently intact — the populations still look right, and the computation is already ruined.

The physical cause is almost always a slightly fluctuating environment. If a stray magnetic field wobbles, the qubit’s energy gap wobbles, so its phase advances at a slightly wrong rate. Repeat over many uncontrolled fluctuations and the phase randomizes.

The two are related by a hard bound:

T_2 \le 2T_1

Energy loss necessarily destroys phase, so dephasing can never outlast relaxation by more than that factor. In practice T₂ is usually well below its ceiling, which tells you dephasing dominates.

You’ll also meet T₂* — dephasing measured without any correction — versus T₂ (echo), measured with pulse sequences that cancel slow drift, borrowed wholesale from NMR. Echo numbers are often several times larger. When comparing across companies, check which is being quoted, because it is frequently not the same one.

Why 99.9% is the number

Every gate is imperfect. Fidelity measures how close the operation you performed is to the one you intended: 99% fidelity means roughly one part in a hundred of the outcome is wrong.

Errors accumulate. At 99% two-qubit fidelity, a circuit of 100 two-qubit gates is mostly noise. Useful algorithms need millions to billions of gates. Extrapolate and the conclusion is brutal: no achievable hardware fidelity is good enough. Not 99.9%, not 99.999%. Direct execution of a useful algorithm on physical qubits is not going to happen.

This was understood to be a crisis in the mid-1990s, and it was solved theoretically before the hardware existed to test it.

Error correction, and why the obvious approach fails

Classical error correction copies. Store each bit three times, and if one flips, majority-vote it back.

Neither half of that works quantumly. You cannot copy an unknown quantum state — the no-cloning theorem, a direct consequence of the linearity of quantum mechanics, not an engineering limitation. And you cannot look at the qubits to check them, because measurement collapses the superposition you’re trying to protect.

So: you must detect errors without copying the data, and without learning what the data is.

The resolution, due to Peter Shor and Andrew Steane in the mid-1990s, is one of the genuinely beautiful ideas in the field. Spread one logical qubit’s information across many physical qubits, in a way that makes it a property of the whole collection and not present in any individual member. Then measure parities — “do qubits 3 and 4 agree?” — rather than states. A parity check reveals whether an error occurred and where, while revealing nothing about the encoded value. The superposition survives; only the error is exposed.

The threshold theorem

Then comes the result the entire industry is built on. If your physical error rate is below some critical threshold, error correction removes errors faster than it introduces them. Below threshold, adding more physical qubits per logical qubit makes the logical error rate fall exponentially. Above threshold, correction adds more noise than it removes, and more hardware makes things worse.

There is no gradual crossover. It is a phase transition, and which side of it you are on is the single most consequential fact about a quantum computer.

For the surface code — the leading scheme for platforms with only nearest-neighbour connectivity, which includes most superconducting and semiconductor devices — the threshold sits near 1% per operation. That is the origin of the 99.9% target: you need to be comfortably below threshold, not marginally, because the margin sets the overhead.

And the overhead is enormous. Depending on physical error rate and target logical error rate, one logical qubit costs somewhere between hundreds and thousands of physical ones. This is why a 1,000-physical-qubit machine is not close to a 1,000-logical-qubit machine, and why headline qubit counts are the least informative number a company publishes.

The single most important sentence in this series: qubit count is not the metric. The metric is how many logical qubits you can build and how reliably they operate — which is a question about fidelity, connectivity, and error-correction overhead, not inventory.

In 2024, Google’s Quantum AI team published the first convincing demonstration of operating below threshold: as they increased the surface-code distance from 3 to 5 to 7, the logical error rate fell at each step, roughly halving. That is the experimental signature the theory predicts, and it converted the threshold theorem from mathematics into an engineering roadmap. Post 3 covers it properly.

Not everyone is building surface codes. IBM is pursuing qLDPC codes with dramatically lower overhead at the cost of requiring long-range connections. Neutral-atom platforms exploit their ability to physically move qubits mid-computation, changing the cost model entirely. Alice & Bob and AWS build qubits whose errors are deliberately biased — overwhelmingly one type — so a much cheaper code suffices. Quantum Circuits builds qubits that announce their own failures, and knowing where an error occurred is worth far more than knowing one occurred somewhere.

Each of those is a different answer to the same question: error correction is expensive, so what physics can you buy it with? That question organizes most of this series.

How to read the numbers

Every post opens with a stat block. Some guidance on reading them, and on reading company announcements generally.

A fidelity without a benchmark isn’t a measurement. Randomized benchmarking, cross-entropy benchmarking, and cycle benchmarking measure different things and give different numbers on the same hardware. Always check which.

Best versus median matters enormously. “99.9% two-qubit fidelity” might mean the best pair on the chip on a good day, or the median across all pairs, or the worst case across all pairs. The spread between these is often wider than the spread between companies.

Physical and logical qubits are different units. Treating them as interchangeable is the most common error in coverage of this field.

Component results are not system results. A record fidelity on two qubits in a research device tells you something real about the physics and very little about a 100-qubit processor.

Roadmaps are not results. They’re legitimate and necessary — you cannot build hardware without a plan. They are simply not measurements, and this series will consistently distinguish them.

One more caution, about the stat blocks specifically. Across this series the numbers in them span nine orders of magnitude in coherence time and four in operating temperature. That spread is genuinely informative: it tells you these are radically different physical objects. But the numbers are not directly comparable between platforms, because they’re measured by different benchmarks against different definitions of a qubit and a gate. The stat blocks exist so you can see the shape of each platform’s trade-offs. They are not a scoreboard, and this series will never total them into one.

What’s coming

Twenty-seven posts, grouped by physics rather than by prominence.

Superconducting circuits (posts 2–8) come first, because the transmon is the most-studied qubit in existence and the best-documented. IBM, Google, Rigetti, IQM, then the companies building fundamentally different circuits: cat qubits at Alice & Bob and AWS, erasure and bosonic qubits at Quantum Circuits and Nord Quantique.

Trapped ions (posts 9–12) — identical qubits by construction, the highest fidelities anyone has measured, and a hard scaling problem. Quantinuum, IonQ, and the companies trying to replace lasers with on-chip electronics.

Neutral atoms (posts 13–16) — the platform that can physically rearrange its qubits mid-computation, which nothing else can do. QuEra, Pasqal, Atom Computing, Infleqtion, planqc.

Semiconductor spins (posts 17–19) — the smallest qubits, potentially manufacturable in existing fabs, and the furthest behind. Intel, Silicon Quantum Computing, and the foundry bet.

Photonics (posts 20–23) — room temperature, natively networkable, and burdened with the hardest two-qubit gate problem in the field, because photons don’t interact. PsiQuantum, Xanadu, Quandela, Photonic Inc.

The other bets (posts 24–27) — Microsoft’s topological qubits, D-Wave’s annealers, diamond NV centres that run at room temperature, and the state programmes.

Post 28 puts every stat block in one table and asks what the physics says: which trade-offs generate which architectures, and where each modality’s physical wall actually sits.

Next week: IBM, the transmon, and why a Josephson junction is the only circuit element that makes any of this possible.

This series explains the physics of quantum computing hardware. It is not investment advice, and it does not rank or evaluate companies as businesses.

References

• D. P. DiVincenzo, “The Physical Implementation of Quantum Computation,” Fortschritte der Physik 48, 771 (2000). arXiv:quant-ph/0002077
• P. W. Shor, “Scheme for reducing decoherence in quantum computer memory,” Phys. Rev. A 52, R2493 (1995).
• A. M. Steane, “Error Correcting Codes in Quantum Theory,” Phys. Rev. Lett. 77, 793 (1996).
• W. K. Wootters and W. H. Zurek, “A single quantum cannot be cloned,” Nature 299, 802 (1982).
• A. G. Fowler, M. Mariantoni, J. M. Martinis, A. N. Cleland, “Surface codes: Towards practical large-scale quantum computation,” Phys. Rev. A 86, 032324 (2012). arXiv:1208.0928
• Google Quantum AI, “Quantum error correction below the surface code threshold,” Nature 638, 920 (2025). arXiv:2408.13687
• M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information, Cambridge University Press (2010). The standard reference.