Distance and Rate Tradeoffs
A code cannot maximize protection, efficiency, and locality at once, and where a family sits among these competing goals decides where it is useful.
Three competing quantities
A code's parameters [[n,k,d]] capture the tension directly: n physical qubits carry k logical qubits with distance d. Rate is k/n, the encoding efficiency. Distance d sets how many errors are corrected. Designers want high rate and high distance from few qubits, but the two pull against each other and against a third goal, geometric locality of the checks.
How the families line up
The surface code has rate that falls to zero as it grows (one logical qubit per patch) and distance scaling like the square root of n, but its checks are local on a 2D grid, ideal for planar hardware. Good quantum LDPC codes hold rate constant and make distance grow linearly with n, but require non-local checks. Concatenated codes sit in between with tunable but overhead-heavy scaling.
- Rate = k/n, the fraction of qubits that carry logical information.
- Distance sets the number of correctable errors, floor((d-1)/2).
- Locality of checks determines which hardware can run the code.
- No family maximizes rate, distance, and 2D-locality simultaneously.
A theorem of Bravyi, Poulin, and Terhal makes the tension precise for local codes: a code whose stabilizers are geometrically local in two dimensions obeys k times d squared, at most a constant times n. So in strict 2D, high rate and high distance cannot coexist, which is exactly why high-rate LDPC codes need long-range connectivity.
The practical reading is that no single code is best for everything. A machine may use a high-rate LDPC memory to store many idle logical qubits cheaply, and move data into surface-code patches for gates, choosing each code for the job where its point on the trade-off surface is strongest.