What is a qubit, and how does a quantum computer actually work?

Status as of: August 2026. This is a definitions post — the entry door to the rest of this library. Almost everything below is stable textbook physics (Nielsen & Chuang, 2010); the few state-of-the-art numbers carry their own source and date. One warning before we start: the most common popular explanation of quantum computing — "it tries every answer at once" — is wrong, and believing it will make you misread every vendor announcement you see. We take that myth apart below.

What is a bit?

A bit is the smallest unit of classical information: a system with exactly two distinguishable states, written 0 and 1. Three properties matter for the comparison ahead, all deterministic:

1. It is always in one definite state. A bit is 0 or it is 1. There is no third option and no in-between.
2. Reading it is free and faithful. You can look at a bit without changing it, and you always read back what was stored.
3. Copying is trivial. Any classical memory does it billions of times per second.

Everything your current computer does — this page, the network that delivered it — reduces to deterministic operations on definite bits.

What is a qubit?

A qubit is a two-level quantum system. Its state is described not by "0 or 1" but by two complex numbers — amplitudes — written α|0⟩ + β|1⟩, with |α|² + |β|² = 1. The differences from a bit are structural, not cosmetic:

1. Superposition. Until measured, the qubit does not hold a hidden definite answer. The pair (α, β) is the complete physical description — a direction on a sphere, not a coin already lying heads or tails under a cup.
2. Measurement is probabilistic and destructive. When you read a qubit you do not get α and β. You get one classical bit: 0 with probability |α|², 1 with probability |β|². The superposition is gone afterward — readout collapses the state.
3. No copying. The no-cloning theorem forbids copying an unknown quantum state (Nielsen & Chuang, 2010). You cannot "just read it twice."

Why do N qubits need 2^N numbers?

One qubit needs 2 amplitudes. Two qubits need 4 — one per joint outcome (00, 01, 10, 11). N qubits need 2^N amplitudes, one for every possible bitstring. Fifty qubits already implies 2⁵⁰ ≈ 10¹⁵ amplitudes — more numbers than any laptop holds in RAM, which is exactly why simulating quantum systems classically gets expensive fast.

Entanglement is what makes the joint description irreducible. Two entangled qubits cannot be described as "qubit A is in state x, qubit B is in state y" — only the joint 4-amplitude object exists. Correlations between measurement outcomes appear that no pair of independent coins can reproduce. Entanglement is not a communication channel; it is a correlation resource, and it is the raw material every quantum algorithm works with.

Does a quantum computer try all answers at once? (No.)

Here is the myth, verbatim from a thousand headlines: "with N qubits, a quantum computer explores 2^N solutions in parallel." The first half is true — the state vector does carry 2^N amplitudes. The second half is the error, and it dies on one fact you already know from this page: measurement returns one outcome. If you put a register in an equal superposition of all 2^N bitstrings and simply measure it, you get one random bitstring. That is a very expensive random-number generator, not a search of 2^N answers.

What actually produces speedups is interference. Amplitudes are complex numbers: they can be negative, they can point in opposing directions, they can cancel. A quantum algorithm is a choreography of gates that steers the 2^N amplitudes so that paths leading to wrong answers cancel out and paths leading to right answers reinforce — so that when you finally measure, the probability mass has been concentrated on the useful outcome. Scott Aaronson has spent two decades repeating this ("Read the fine print", Nature Physics, 2015): the parallelism picture is not a harmless simplification, because it predicts speedups everywhere, and interference choreography only exists for problems with the right structure.

That single correction explains the shape of the entire field: why factoring gets an exponential speedup (Shor — see our advantage vs. supremacy explainer), why unstructured search gets only a quadratic one, and why for most business optimization problems no measured advantage exists at all. The machine is not a brute-forcer with 2^N arms. It is an interference instrument, and only some problems have the structure an interference instrument can exploit.

What does the physical machine look like?

A qubit has to be a real physical object that holds a fragile superposition. The two leading implementations today:

• Superconducting circuits (IBM, Google, Rigetti): micro-fabricated resonant circuits on a chip, held near absolute zero inside a dilution refrigerator — IBM reports operating temperatures around 25 millikelvin (IBM Quantum blog, Sep 2022), colder than outer space. Gates are microwave pulses; they are fast, but coherence lasts on the order of microseconds to milliseconds.
• Trapped ions (IonQ, Quantinuum): individual charged atoms suspended in electromagnetic fields, manipulated with lasers. Gates are slower, but a single ion qubit has held its state with an estimated coherence time exceeding one hour — 5,500 s measured (Wang et al., Nature Communications, 2021).

A gate — the quantum analogue of a logic gate — is a controlled rotation of amplitudes: a calibrated microwave or laser pulse that rotates the state vector by a precise angle. Programs are sequences of these rotations, plus entangling gates that couple pairs of qubits.

The enemy is decoherence: any stray interaction with the environment — heat, vibration, radiation — measures the qubit before you meant to, and the superposition leaks away. This is why the fridge, why the vacuum chamber, and why every number in a quantum roadmap is really a fight against noise. It is also why the field distinguishes physical qubits (the noisy hardware objects) from logical qubits (error-corrected bundles of many physical qubits that behave like one better qubit). The best published demonstration to date: Google's Willow chip encoded 1 logical qubit into 101 physical qubits (distance-7 surface code) and got a logical error rate of 0.143% per correction cycle — with errors halving (Λ = 2.14) each time the code distance grows by 2, and a logical lifetime 2.4× better than the best physical qubit on the chip (Nature, Dec 9, 2024). That is a milestone, and it is also the honest scale of things: about a hundred physical qubits bought one logical qubit that still errs once per ~700 cycles. What that ratio will cost at scale is a roadmap question, not a measured fact — our timing post reads those roadmaps.

What happens when you actually run a program?

Nobody types on a quantum computer. The real pipeline, end to end:

1. Write a circuit on your laptop: a sequence of gates on N qubits, in a framework like Qiskit or Braket.
2. Compile. The circuit is rewritten into the machine's native gate set and mapped onto its qubit layout — extra gates are inserted wherever your circuit wants to couple qubits the chip doesn't physically connect.
3. Execute. The pulses run through the fridge or the trap. Total circuit time is limited by decoherence: finish before the state degrades.
4. Measure — and repeat thousands of times. One execution yields one bitstring. Because outcomes are probabilistic and hardware is noisy, the platform re-runs the circuit for many "shots" — IBM's Sampler defaults to 4,096 shots per job (IBM docs, accessed Aug 2026).
5. Read the histogram. The deliverable is a frequency distribution over bitstrings. Your answer is the pattern in that distribution — which is also why cost scales with shots, and why error mitigation multiplies shot counts.

What we know / what we don't know

What we know. The physics above is settled, textbook material: amplitudes, probabilistic measurement, no-cloning, interference as the actual mechanism of speedup. The Willow error-correction result is peer-reviewed and published. The "tries everything in parallel" picture is wrong as a matter of established quantum mechanics, not as a matter of opinion.

What we don't know.

• Which hardware architecture wins. Superconducting is faster, ions are more stable and connected; neither has a decisive, measured, end-to-end lead, and photonics and neutral atoms are also in the race.
• What a logical qubit will end up costing. 101-to-1 is one demo at distance 7. Whether the physical-per-logical ratio at useful scale lands near 100, 1,000, or worse depends on codes and engineering that are still moving; vendor roadmap ratios (which we read critically here) are targets, not results.
• Whether Λ holds at scale. Willow's error suppression (2.14× per distance step) is measured up to distance 7. Sustaining it at the distances real algorithms need is projected, not demonstrated.
• When any of this beats classical machines on a useful problem. Understanding the mechanism honestly is exactly what shows how much is still missing — our crossover explainer and risk-management verdict track that gap with sources. Rosetta's own sealed runs so far are in small optimization classes, where the classical baseline is undefeated.

Sources

• Nielsen & Chuang, Quantum Computation and Quantum Information, Cambridge UP (2010) — doi.org/10.1017/CBO9780511976667
• Aaronson, "Read the fine print", Nature Physics 11, 291–293 (2015) — nature.com/articles/nphys3272
• Google Quantum AI, "Quantum error correction below the surface code threshold", Nature 638, 920–926 (Dec 9, 2024) — nature.com/articles/s41586-024-08449-y
• Wang et al., "Single ion qubit with estimated coherence time exceeding one hour", Nature Communications 12, 233 (2021) — nature.com/articles/s41467-020-20330-w
• IBM Quantum blog, Project Goldeneye (Sep 8, 2022) — ibm.com/quantum/blog/goldeneye-cryogenic-concept-system
• IBM Qiskit Runtime docs, SamplerOptions (accessed Aug 2026) — quantum.cloud.ibm.com/docs

Rosetta Q publishes verdicts with reproducible raw data. This is educational content, not a product claim.