Qubit: what it is, how it works and why it is the unit of quantum computing

All quantum computing rests on a single building block, the qubit. Understanding what it is, how it behaves and how it differs from the traditional bit is the compulsory step for anyone who wants to assess quantum technologies seriously, from the researcher to the corporate decision maker.

On this page we answer the most frequent questions, from the definition of a qubit to the mathematics that describes it, from the technologies used to build it in the laboratory to the problem of measurement and fragility, through to the distinction between physical and logical devices and how to experiment concretely without owning a quantum computer, thanks to quantum emulation, the ground on which HumanQ already develops concrete projects today.

Each section answers a real research question, so that it can also be read on its own.

What is a qubit?

The qubit, or qbit, a contraction of quantum bit, is the elementary unit of quantum information: it is a physical system with two distinguishable levels, conventionally written |0⟩ and |1⟩, governed by the laws of quantum mechanics. The substantial difference with respect to any classical information carrier is that the two states, or levels, are not mutually exclusive, because for as long as the system stays isolated it can occupy a combination of the two states, with weights that the quantum algorithm can manipulate. The term was introduced by the physicist Benjamin Schumacher in the 1990s and today denotes both the mathematical abstraction and the concrete device that implements it. An encyclopaedic treatment is available on Wikipedia. One terminological note is in order, since the literature also uses the extended form quantum bit, entirely equivalent, and in this guide the two terms are used as synonyms.

What is the difference between a bit and a qubit?

The classical bit is a switch that at any instant is either 0 or 1, and reading its value does not alter it. Its quantum counterpart is described instead by two complex amplitudes and lives in a continuous space of possible states (it holds a non-zero weight on both values, 0 and 1), while reading it, that is measuring it, forces it to settle on one of the two values and destroys the intermediate information.

The most important consequence is combinatorial, because n bits hold a single configuration out of 2ⁿ, whereas n qubits describe all 2ⁿ configurations simultaneously through their respective amplitudes. It is this exponential growth of the state space, together with quantum entanglement, that is the technological resource no classical server possesses today.

How is the quantum state represented mathematically?

The state of a qubit has a very elegant geometric representation, the Bloch sphere, in which every point on the surface corresponds to a possible state. The poles represent the classical states 0 and 1, while all the other points are superpositions, and single-input logic gates are visualised as rotations of the vector on the sphere.

Two-qubit gates, such as the CNOT, generate instead non-classical correlations between two spheres, and it is from these correlations that entanglement arises. The section on how a quantum computer works shows how these rotations combine into entire algorithms for quantum computation.

The pure-state formalism

A pure state is written |ψ⟩ = α|0⟩ + β|1⟩, subject to the normalisation condition |α|² + |β|² = 1. A more expressive parametrisation uses the angles of the Bloch sphere, |ψ⟩ = cos(θ/2)|0⟩ + e^iφ sin(θ/2)|1⟩, where θ and φ identify a point on the surface of the sphere and the global phase is physically irrelevant. Single-qubit gates are therefore unitary rotations of this vector.

What does being in a superposition of states mean?

Quantum superposition is often told as "being 0 and 1 at the same time", but the rigorous formulation is subtler, because the system holds non-zero amplitudes on both outcomes, and those amplitudes can interfere with one another like waves, adding together or cancelling out.

Quantum algorithms exploit precisely this interference to amplify the correct answers and suppress the wrong ones; superposition is therefore not a free parallelism trick, given that extracting the result requires modelling the phases with precision, which is the reason why designing effective quantum algorithms is a discipline in its own right. A typical example is the Deutsch-Jozsa algorithm, in which a single query, orchestrated on the phases, solves a problem that classically would instead require at least half plus one of the possible checks, showing in a scientific and experimental way the logic behind every interference-based approach.

How are qubits physically built?

Any controllable two-level quantum system can act as a qubit, and the industrial race has selected a few main platforms.

• Superconducting circuits cooled to millikelvin temperatures, the route followed by IBM and Google.
• Trapped ions manipulated with lasers, the route of IonQ and Quantinuum.
• Neutral atoms in optical tweezers.
• Photons in photonic circuits.
• Electron spins in semiconductors, the route closest to the chip industry.

Each technology offers a different trade-off between operation fidelity, speed, connectivity and scalability, and none has yet established itself as dominant over the others. European and Italian research centres, coordinated among others by the Quantum Flagship, work on several platforms in parallel. To the families listed above one should add hybrid and topological approaches, still experimental, which promise intrinsic protection against errors.

What happens at the moment of measurement?

Measurement is the act that brings the quantum world back to the classical one, because interrogating the system in the computational basis returns 0 with probability |α|² and 1 with probability |β|², according to the Born rule, and from that instant the state coincides with the observed outcome. The information held in the amplitudes is therefore no longer directly readable, and it is for this reason that a well-designed algorithm concentrates the probability on the useful outcome before triggering the measurement. To this must finally be added decoherence, the involuntary measurement performed by the interference of the environment, which degrades the state within extremely short times. This is the main reason that forces physical hardware into extreme isolation.

Coherence times in the physical world vary enormously across the different platforms, from the microseconds of superconducting circuits to the seconds, and beyond, of trapped ions, and it is within this window that the entire circuit has to complete, which is why gate speed and coherence duration should always be read together.

Why are logical qubits and error correction needed?

Physical devices are noisy, given that every gate introduces a small error and decoherence does the rest. Quantum error correction solves the problem by encoding the information redundantly, making many physical qubits cooperate to represent a single logical qubit, protected and reliable. Current ratios range from tens to thousands of physical units for each logical one, depending on the code used and the quality of the hardware employed. This is the reason why the raw count of a processor says very little about the performance of the system, because what matters is the quality of the qubits and how many logical qubits can in turn be obtained from them.

How many qubits do quantum computers have today?

The question needs disambiguating before it can be answered, because the word qubit denotes two very different quantities. In terms of physical qubits, the thousand-unit threshold was crossed at the end of 2023, when IBM presented the Condor processor with 1,121 superconducting units, while neutral-atom platforms reached comparable figures; IBM itself, however, reported performance comparable to that of the earlier 433-unit Osprey, which confirms that the milestone concerned fabrication yield and chip density rather than the computing power actually available. In terms of logical qubits, that is the units protected by error correction and the only ones that count for an algorithm of any depth, verified results are still in the order of tens, with the best figures published between 2024 and 2026 ranging from a handful to around one hundred, obtained by spending from a few tens to several hundred physical qubits on each logical one, depending on the code adopted.

We are therefore still in the NISQ era, that is noisy, uncorrected and suited to experiments and prototypes rather than to production. The roadmaps of the main manufacturers place the first systems with a few hundred corrected logical qubits towards the end of the decade, but the estimates should be read with caution, because the scalability of error correction is itself a research challenge that is still wide open. Real industrial problems will require thousands of logical units, that is millions of physical components, a goal that is still distant and that therefore makes the alternatives available today all the more valuable, starting with emulation, where circuits are developed and validated without waiting for that hardware.

Is the number of qubits the only metric that counts?

No, and it is a simplification to be wary of. The relevant metrics include gate fidelity, that is how accurate each operation is, coherence times, that is how long the state survives, connectivity, that is which pairs can interact directly, the executable circuit depth and aggregate metrics such as quantum volume. A processor with a few excellent units can be more useful than an instrument with many technical limitations. Anyone assessing these projects should always investigate these figures, and be wary of comparisons built on qubit count alone, since that is often marketing rather than engineering. The same metrics apply, symmetrically, to judging the quality of an emulation environment.

How can you experiment with qubits without quantum hardware?

The answer is quantum emulation, in which a high-performance classical infrastructure reproduces the algebra of qubits exactly, making it possible to build circuits, inspect intermediate states, something impossible on real hardware where measurement is also immediately destructive, switch on controlled noise models and repeat every run deterministically.

Quantum emulation is the ideal tool for training, research and industrial prototyping, and it is exactly the ground on which HumanQ develops its own quantum emulation projects, with one precise guiding principle, namely keeping the focus on what can be developed today, instead of waiting for hardware that will mature on timescales and at costs that are still very uncertain.

Compared with the quantum simulation of physical systems, emulation replicates the theory of computation, not the physical machine (simulation). On the operational side, the emulation system also makes it possible to compare different versions of the same circuit side by side, measuring how fidelity and depth change, an optimisation cycle that on real hardware would carry prohibitive costs and timescales and that in emulation closes instead within a few hours of preparatory work.