Physical vs Logical Qubits

To overcome the devastating impact of physical errors, quantum computer scientists developed the concept of the 'logical qubit'. A logical qubit is a highly protected, virtual qubit constructed by grouping multiple physical qubits together and manipulating them collectively. While individual physical qubits are highly susceptible to environmental noise, the logical qubit uses quantum redundancy to detect and correct errors, maintaining its quantum state indefinitely.

This separation of physical hardware from logical information is the cornerstone of scalable quantum computing. It allows us to write quantum algorithms for perfect, noise-free logical qubits, while the underlying hardware and control systems handle the complex task of error correction. This abstraction layer is analogous to how classical software developers write code without worrying about individual transistor failures.

In this topic, we will explore the mathematical and conceptual differences between physical and logical qubits. We will examine the overhead ratio, the number of physical qubits required to create a single logical qubit, and see how this ratio depends on the physical error rate and the desired level of protection. This understanding is crucial for evaluating the true scale of future quantum computers.

The best way to understand the relationship between physical and logical qubits is through the analogy of a RAID (Redundant Array of Independent Disks) system used in classical data storage. If you store your precious photos on a single physical hard drive, any mechanical failure will result in permanent data loss. To prevent this, a RAID system groups multiple physical hard drives together to act as a single 'logical' drive. Even if one or two physical drives crash, the system uses redundant data distributed across the remaining drives to reconstruct the lost files without interrupting your work.

Another analogy is a spelling bee team. If a single student is asked to spell a highly complex word, they might make a typo due to stress or fatigue. However, if a team of five students is asked to discuss and vote on each letter, the team as a whole (the 'logical' speller) is far more likely to produce the correct spelling, even if individual members (the 'physical' spellers) occasionally make mistakes.

In the quantum world, a logical qubit is like that spelling team or RAID array. We distribute the quantum state of a single logical qubit across a highly entangled state of many physical qubits. By constantly monitoring the relationships between these physical qubits, we can identify and correct individual physical failures before they corrupt the logical information.

Mathematically, a physical qubit is a two-level quantum system described by a state vector in a two-dimensional Hilbert space $\mathcal{H}_2$: $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$. A logical qubit, however, is encoded in a carefully selected subspace, the code space $\mathcal{C}$, of a much larger Hilbert space $\mathcal{H}_{2^n}$ formed by $n$ physical qubits.

To encode a single logical qubit, we map the logical basis states $|0_L\rangle$ and $|1_L\rangle$ to highly entangled multi-qubit states of $n$ physical qubits. For example, in a simple 3-qubit repetition code, the mapping is:

$$|0_L\rangle = |000\rangle$$ $$|1_L\rangle = |111\rangle$$

An arbitrary logical state is represented as:

$$|\psi_L\rangle = \alpha|0_L\rangle + \beta|1_L\rangle = \alpha|000\rangle + \beta|111\rangle$$

The number of physical qubits $n$ required to encode a logical qubit is determined by the code distance $d$. The code distance is the minimum number of physical qubit operations (errors) required to transform the logical state $|0_L\rangle$ into $|1_L\rangle$. A code with distance $d$ can detect up to $d-1$ physical errors and correct up to $t$ physical errors, where:

$$t = \left\lfloor \frac{d - 1}{2} \right\rfloor$$

For a 2D surface code, the number of physical qubits scales quadratically with the distance, roughly $n \approx 2d^2$. If the physical error rate is below a certain threshold, increasing $d$ (and thus $n$) exponentially suppresses the logical error rate $\epsilon_L$:

$$\epsilon_L \propto \left( \frac{\epsilon_p}{\epsilon_{th}} \right)^{\frac{d+1}{2}}$$

where $\epsilon_p$ is the physical error rate and $\epsilon_{th}$ is the fault-tolerance threshold.