Logical vs. Physical Qubits

A qubit's earplug (explained later)
Image source

Introduction

So far, we referred to qubits as the fundamental unit of quantum computing while explaining quantum circuits like Deutsch-Josza and Shor’s algorithm. But here’s the catch: all those explanations assumed perfect qubits–qubits that exists in flawless superposition and entanglement (i.e., never lose coherence), and execute gates with absolute precision.

In reality, quantum hardware is far from perfect.

The “ideal” qubits we’ve been talking about are actually called logical qubits, theoretical constructs used in quantum algorithms. The physical qubits, the ones implemented in real quantum computers, are a whole different story–they’re fragile, noisy, and prone to errors.

If this sounds familiar, that’s because the same thing happens in classical computers. The logical bits we use in programming (C, Java, Python, etc.) are abstract, error-free 0s and 1s that behave exactly as we expect. But the physical bits inside memory chips are vulnerable to temperature, radiation, and electrical noise.

Physical Qubit: The Fragile Reality of Quantum Hardware

A physical qubit is a real, hardware-implemented qubit in an actual quantum computer. Just like (classical) physical bits are physically realized by transistors, physical qubits are realized using various quantum systems, such as:

• Superconducting circuits (used by IBM and Google)
• Trapped ions (used by IonQ)
• Photons (used by Xanadu)

(We’ll cover these implementations in detail in future articles.)

Compared to classical physical bits, physical qubits are much more fragile. They are affected by various error sources, such as:

• Decoherence: Loss of quantum state over time.
• Gate errors: Imperfect operations on qubits.
• Noise & Crosstalk: Unwanted interactions between qubits.
• Readout errors: Mistakes when measuring the qubit state.

These errors don’t just make things inconvenient–they can completely destroy a computation.

Decoherence: the Biggest Challenge

Of all the error sources, decoherence is the biggest challenge. It’s the biggest reason why quantum computing is still in its early days and why we don’t have million-qubit quantum computers yet.

Decoherence happens because a qubit is never truly isolated–it constantly interacts with its surrounding environment. Think of it like trying to sleep while your neighbors are throwing an all-night party. No matter how hard you try to block out the noise, some of it gets through, keeping you from fully sleeping.

In quantum computing, we call this “sleeping time” the coherence time–the duration a qubit can maintain its quantum state before noise from the environment scrambles it. The longer the coherence time, the better the qubit.

Coherence time fundamentally limits how long we can run quantum algorithms before everything falls apart. This is why current quantum hardware can only execute relatively short computations before errors become overwhelming.

Fun Fact: The futuristic-looking machines you see in quantum computing news articles–the ones with the golden cylindrical structures–are not actually qubits themselves. They’re the “earplugs” we put on qubits to protect them from the noise of their neighbors. The actual qubits are tiny components buried deep inside those structures.

Are Logical Qubits Imaginary?

Not quite. Logical qubits do exist, but we don’t get them for free. Instead of being physical objects, logical qubits are virtually built from multiple physical qubits using error correction techniques.

The idea is simple: if a single physical qubit is too fragile to be reliable, why not spread the information across multiple qubits? This redundancy allows us to detect and correct errors without disturbing the quantum information itself.

Of course, this comes with a cost: it takes a lot of physical qubits just to create a single high-quality logical qubit. And even with error correction, today’s quantum computers aren’t yet at the scale where logical qubits are fully practical.

In the next few articles, we’ll explore why error correction is so tricky in quantum computing (no-cloning theorem) and how we can overcome the no-cloning theorem to build reliable logical qubits.