The Key to Commercial Quantum Computing: How Far Have Surface Codes and Logical Qubits Come?

\n

The Real Bottleneck in Quantum Computing: Not the Number of Qubits, but Reliability

The number that will determine the future of quantum computers is not simply “How many physical qubits are there?” Even if a system contains hundreds or thousands of qubits, if errors accumulate as computations proceed and make the results impossible to trust, it remains closer to a sophisticated experimental apparatus than a commercially viable computer.

This is the greatest paradox facing Quantum Computing today. The more qubits are connected, the more complex the calculations should become. In reality, however, as the number of connected qubits increases, so does the number of points where errors can occur.

Why Do Errors Accumulate So Quickly?

Quantum computers perform calculations using superposition, in which qubits can represent 0 and 1 simultaneously, and entanglement, in which multiple qubits become strongly interconnected. Yet these states are extremely fragile.

Even tiny amounts of heat from the surrounding environment, electromagnetic noise, fluctuations in control signals, or errors during measurement can alter or erase the information stored in a qubit. These are known as decoherence and gate errors.

The problem is that as a quantum algorithm grows longer, errors do not simply occur once and stop there.

• The more qubits there are, the more elements must be controlled.
• The more operations performed between qubits, the more gate errors accumulate.
• Errors can also occur during the measurement process.
• An error in one qubit can affect the computational results of other entangled qubits.

In other words, the classical computing intuition that “adding more qubits improves performance” does not apply directly to the quantum realm. Without effective error management, scaling up may expand not computational power, but instability.

The Difference Between Physical Qubits and Logical Qubits

To understand this problem, it is essential to distinguish between physical qubits and logical qubits.

A physical qubit is an individual qubit that exists on an actual quantum chip or device. Whether implemented using superconducting circuits, trapped ions, neutral atoms, or photons, all physical qubits are vulnerable to external noise and control errors.

A logical qubit, by contrast, is a virtual, more error-resistant qubit created by combining multiple physical qubits. Even if one physical qubit becomes unstable, the system is designed to examine the states of surrounding qubits, estimate the location and type of the error, and recover the computation.

Put simply, if physical qubits are individual components, logical qubits are highly reliable system units designed to continue functioning even when some components fail.

The key metric for a commercially viable quantum computer is not the number of physical qubits, but how many stable logical qubits can be created—and how reliably.

The Turning Point Where ‘Bigger’ Becomes ‘More Stable’

The goal of quantum error correction is clear: continuously detect and correct errors occurring in physical qubits, ultimately reducing the error rate of logical qubits to extremely low levels.

This is where the concept of an error threshold becomes crucial. Once the error rate of physical qubits falls below a certain level, increasing the number of qubits and building larger error-correction codes can actually reduce the logical error rate.

The importance of this turning point is straightforward:

• Above the threshold, adding more qubits does not bring errors under control.
• Below the threshold, the reliability of the computation increases as more qubits are added.
• Only after reaching this state can long algorithms and complex problems be executed reliably.

The currently prominent surface code is one of the leading methods for implementing this type of error correction. Data qubits and auxiliary qubits used for error measurement are arranged on a two-dimensional grid, and repeated measurements are used to identify traces of errors. The key is to obtain clues about whether an error has occurred without directly reading out and collapsing the quantum information itself.

Quantum Computing’s Competitive Edge Begins After the Qubit Count

Thousands of physical qubits are certainly an important milestone. But that alone is not enough to solve demanding problems such as drug discovery, new-material simulations, cryptanalysis, and large-scale optimization.

Such calculations require a level of stability that allows countless operations to be performed in sequence without the results collapsing. Therefore, when evaluating Quantum Computing companies in the future, the following questions will become even more important:

• How low are the gate and measurement error rates of their physical qubits?
• Does the system operate below the error-correction threshold?
• How many physical qubits are required to implement a single logical qubit?
• Does the logical qubit error rate actually decrease as the system scales?

Ultimately, there is only one standard for transforming quantum computing from a laboratory possibility into an industrial tool: When more qubits are connected, can they produce greater reliability—not simply more errors?

Why Physical Qubits and Logical Qubits Matter in Quantum Computing

If a “1,000-qubit quantum computer” were announced today, could we take that number as a direct measure of its performance?

The answer is not yet. In Quantum Computing, the number of qubits physically installed in a device—the number of physical qubits—is an important metric, but it does not directly indicate commercial computing power. What matters more is the number and quality of logical qubits capable of performing real algorithms while tolerating errors.

Physical Qubits: Qubits That Exist in Real Hardware

Physical qubits are actual units of quantum information implemented on platforms such as superconducting circuits, trapped ions, neutral atoms, and photons. However, they are extremely sensitive.

Even slight temperature fluctuations, external electromagnetic signals, tiny imperfections in control pulses, or inaccuracies in the measurement process can disturb a qubit’s state. These effects are known as decoherence and gate errors.

The problem is that errors accumulate as quantum algorithms become longer. An algorithm may succeed after only a few operations, yet produce unreliable results when running useful algorithms that require thousands or tens of thousands of operations.

The number of physical qubits shows the scale of the hardware, but it does not guarantee computational reliability.

Logical Qubits: Computational Units Designed to Tolerate Errors

A logical qubit is a virtual, error-resistant qubit created by combining multiple physical qubits. Even if one physical qubit experiences an error, the system can detect and correct it by comparing the states and measurement results of neighboring qubits.

The key to this process is checking only the traces of errors, rather than directly reading the quantum state itself. To do this, ancilla qubits repeatedly perform measurement operations around the data qubits.

The error patterns obtained through these measurements are called syndromes. If a classical computer’s decoder analyzes these syndromes quickly, it can estimate where an error occurred and what type of error it was.

In simple terms, the structure works as follows:

• Data qubits: Store the actual quantum information.
• Ancilla qubits: Measure error signals without reading the data itself.
• Classical decoder: Analyzes the measurement results to infer the location and type of errors.
• Error-correction control system: Performs correction procedures before the computation breaks down.

Only when this entire structure operates reliably can a logical qubit achieve a lower error rate than its physical qubits.

From the “Qubit Count Race” to the Race for Usable Computing Power

The Quantum Computing industry is now moving beyond a simple race to increase the number of physical qubits. Even if a system has hundreds or thousands of physical qubits, it is difficult to perform long computations if it has few error-corrected logical qubits—or if those logical qubits are of low quality.

Therefore, when evaluating a company’s announcement, we should ask the following questions before asking, “How many qubits are there?”

• What are the one-qubit and two-qubit gate error rates of the physical qubits?
• Have measurement errors and decoherence times been improved sufficiently?
• Has the logical error rate actually decreased after error correction?
• Do the logical qubits operate more reliably as the code distance increases?
• Can real-time error detection and classical decoding be performed continuously?

In particular, the result that “increasing the number of physical qubits reduced logical errors” is extremely important. It signals that quantum error correction is beginning to function not merely as an experiment, but as a scalable computing architecture.

Why the Surface Code Is Receiving Attention

One of the leading methods for creating logical qubits is the surface code. The surface code arranges qubits in a two-dimensional grid and is designed so that only nearby qubits interact with one another.

This approach is well suited to hardware that arranges qubits on a chip, such as superconducting qubits. It can also build an error-correction structure without requiring complex long-distance connections, making it widely regarded as the most realistic approach to large-scale quantum error correction today.

However, it comes with a significant cost. Creating a single high-reliability logical qubit may require dozens to hundreds or more physical qubits. To run algorithms that require thousands of logical qubits in the future, the number of physical qubits may need to grow to hundreds of thousands or more.

Ultimately, the Important Number Is the “Usable Logical Qubits”

The true unit of a quantum computer is no longer simply the physical qubit. From an industrial perspective, what matters is how many logical qubits can be maintained, at how low an error rate, and for how long they can perform computations.

In other words, an announcement of “1,000 qubits” is only the starting point. What truly reveals the competitiveness of a Quantum Computing system is how those 1,000 physical qubits are transformed through error correction into reliable logical qubits.

How to Track Errors on the Lattice of a Quantum Computing Surface Code

Quantum errors do not appear as a warning pop-up on a computer screen saying, “An error has occurred.” The moment we look directly at a qubit’s state, the quantum state itself—essential to the computation—could collapse.

Instead, the system reads the traces of errors through subtle changes in measurement results repeatedly collected across the lattice. From those traces alone, it works backward to determine “which qubit experienced what kind of error, and when.” One of the representative structures designed to solve this complex puzzle is the surface code.

A Structure That Reads Only Errors Without Measuring the Data Directly

A surface code arranges qubits on a two-dimensional lattice. These qubits are broadly divided into two roles:

• Data qubits: Store the actual logical quantum information.
• Measurement qubits (ancilla or measure qubits): Check whether errors have occurred in neighboring data qubits.

The key point is that the system does not directly measure the values of the data qubits. Measurement qubits interact with several surrounding data qubits in a prescribed sequence, then measure a specific even–odd pattern—in other words, a stabilizer value.

For example, if the relationships among the surrounding qubits are normal, the measurement results continue to follow the same pattern. But if an error occurs in one of the data qubits along the way, the measurement results connected to that error change from their previous values.

A surface code does not read the “correct state” of a qubit.
It reads whether the relationships that should remain intact under normal conditions have been disrupted.

Errors Appear Not as Points, but as ‘Pattern Changes’

The errors commonly discussed in Quantum Computing are broadly divided into two types:

• Bit-flip error (X error): An error that flips (|0\rangle) to (|1\rangle), or vice versa
• Phase-flip error (Z error): An error that changes the phase relationship of the quantum state even though the visibly observed value remains the same

In a surface code, when an error occurs in a single physical qubit, changes in the results usually appear at two or more neighboring measurement qubits. These are called detection events or syndrome changes.

Suppose a measurement qubit’s result remains +1, +1, +1 for several cycles, then suddenly changes to -1. The system detects the possibility that an error has occurred somewhere in the surrounding area. However, a single change is not enough to determine the exact location with certainty.

That is why a surface code does not measure just once and stop. It repeats the same checks at extremely short intervals and analyzes changes over time as well.

| What is observed | Information obtained by the system | |---|---| | Position on the lattice | In which region did the state relationship change? | | Changes in measurement results | Is there a possibility that an error occurred? | | The flow of repeated measurements over time | When did the error occur? | | Connection patterns among multiple changes | Which error path is the most likely? |

In other words, error correction is not simply a matter of “finding an error.” It is the process of connecting traces scattered across space and time on the lattice and inferring the most plausible cause.

Syndrome Decoder: The Engine That Infers Invisible Error Paths

The syndrome data generated by the measurement qubits is immediately sent to a classical computer. There, a classical algorithm called a decoder goes to work.

The decoder performs the following tasks:

1. Collects which measurement results changed and when.
2. Calculates the distances between change points and the characteristics of hardware errors.
3. Finds the most probable error path.
4. Applies correction information that cancels out the corresponding error on the logical qubit.

An important point is that the system does not necessarily need to execute a physical correction gate immediately. In many cases, error-correction information is stored in the records of the classical control system. This is known as Pauli frame tracking.

For example, if the system determines that an X error occurred on a particular qubit, it records the information that “this qubit should be interpreted as having been logically flipped once.” When interpreting subsequent measurement results or adjusting later operations, the system takes that record into account. This reduces unnecessary physical gates and lowers the possibility of introducing additional errors.

Why Repeated Measurements Matter

Measurement qubits are not perfect either. A measurement itself can be wrong even when no error has occurred in a data qubit. Therefore, confirming a data-qubit error based on a single abnormal signal could lead to an incorrect correction being applied.

The surface code addresses this by repeating the same stabilizer measurement multiple times.

• If an abnormal result appears only once: The system checks whether it may have been a measurement error.
• If changes continue across neighboring locations and consecutive times: An actual data-qubit error becomes more likely.
• If multiple syndromes connect along a particular path: The system analyzes the possibility of multiple errors or error propagation.

Ultimately, a surface code combines spatial information from the two-dimensional lattice with temporal information accumulated through repeated measurements. Error correction is not merely a hardware function; it is closer to a real-time inference system jointly operated by a quantum device and ultra-fast classical computation.

Code Distance: How Many Errors Can It Tolerate?

One of the most important metrics for describing the reliability of a surface code is the code distance. The code distance refers to the minimum length of an error path required to actually damage the logical information.

In general, when the code distance is (d), under ideal conditions it can correct up to

[ \left\lfloor \frac{d-1}{2} \right\rfloor ]

errors.

For example, a distance-3 code can correct one error, while a distance-5 code can correct two errors. Increasing the code distance makes the logical qubit more stable, but it also requires more physical qubits, measurement circuits, and control equipment.

This is the greatest practical challenge facing surface codes. Expanding the lattice to block errors more effectively also increases the number of qubits in which new errors could occur, and those errors must be managed as well. Therefore, only when the gate and measurement error rates of physical qubits are sufficiently low will increasing the code size actually reduce the logical error rate.

Why Surface Codes Are the Gateway to Commercial Quantum Computing

A surface code is not a spectacular quantum algorithm in itself. However, it is a foundational technology that will be essential for carrying out long computations reliably. Tasks such as molecular simulation, cryptanalysis, and large-scale optimization require deep quantum circuits; once small errors accumulate, the entire result becomes impossible to trust.

Therefore, the future competitiveness of Quantum Computing will not depend simply on “how many physical qubits there are.” More important questions include:

• How quickly and accurately can error syndromes be read?
• Are the speed and accuracy of repeated measurements sufficient?
• Can the decoder infer error paths in real time?
• Does the logical error rate actually decrease when the code distance is increased?

Invisible errors occur constantly across the lattice of a surface code. But if a quantum computer can read the tiny traces left in measurement patterns, infer their causes through classical computation, and protect logical information, it can finally move beyond being an experimental device and begin to approach a reliable computing system.

A Turning Point in Quantum Computing: Does Adding More Qubits Make It Stronger After “Break-Even”?

The most dramatic moment in quantum error correction does not simply lie in building more qubits. The true turning point comes when adding physical qubits no longer makes the system more complex and unstable, but instead makes the logical qubits more stable. The point at which researchers first confirm this reversal is what they call break-even.

Today’s physical qubits are highly vulnerable to decoherence, imperfect control signals, and gate and measurement errors. As a result, simply increasing the number of physical qubits also increases the number of places where errors can occur. If error-correction technology is not sufficiently mature, a larger system may become not a more powerful computer, but a system harboring more errors.

This is precisely the problem that surface-code-based Quantum Computing seeks to solve. Multiple physical qubits are grouped into a single logical qubit, while measurement qubits placed around them repeatedly detect signs of errors. The key is to collect only the syndrome—information indicating that an error has occurred—without directly measuring the logical information itself.

What Break-Even Means

Break-even generally refers to a state in which:

• The performance of an error-corrected logical qubit is equal to or better than that of an individual physical qubit
• The logical error rate actually decreases as the code distance increases
• The cost of adding physical qubits leads not merely to greater complexity, but to improved reliability

Code distance is a metric indicating the scale of errors that an error-correcting code can withstand. As the code distance increases, more physical qubits and more error-correction operations are required. However, when the conditions are right, the logical error rate can fall rapidly.

Conceptually, this can be understood as follows:

If the physical error rate is below a certain threshold, increasing the code distance reduces the logical error rate.

In other words, if the hardware’s baseline error rate is sufficiently low and the error-correction circuits operate reliably, increasing the number of qubits is no longer a weakness. Instead, it becomes a resource that produces reliability.

Break-Even and Fault Tolerance Are Different

The confirmation of break-even does not mean that a general-purpose quantum computer has been completed. Break-even is a highly significant experimental milestone, but fault tolerance—fault-tolerant quantum computation—requires a much higher standard.

For fault tolerance to be achieved, the following conditions must all be met:

1. Additional errors introduced during the error-correction process must be controlled.
2. Error detection and correction must be repeated quickly enough to keep pace with computation.
3. Not only must the logical qubit’s memory be preserved, but logical gate operations must also be performed with low error rates.
4. As the system grows, the overall probability of successful computation must be maintained or improved.

Actual algorithms do not end with simply storing a quantum state. Tasks such as molecular simulation, cryptanalysis, and optimization require countless logical gates to be executed sequentially. Therefore, there is a significant technological gap between the result that “a logical qubit survives somewhat longer” and the result that “a long computation can be completed accurately from beginning to end.”

Questions More Important Than the Number of Qubits

When evaluating Quantum Computing companies and research results in the future, the following questions will matter more than simply asking, “How many qubits are there?”

• Does the logical error rate actually decrease as the code distance increases?
• How efficient are the resources required for a logical qubit compared with a physical qubit?
• Is there a classical control system capable of processing error syndromes in real time?
• Has fault-tolerant implementation been achieved not only for logical memory, but also for logical gates?

Ultimately, break-even is a signal that quantum computers are beginning to move beyond the realm of simple experimental equipment. Fault tolerance is the process of transforming that signal into commercially viable computing power. When it is proven that a system becomes stronger as more qubits are added, quantum computing can finally overcome the limits of scale and evolve into a practical computing platform.

Quantum Computing: The Starting Point of Quantum Advantage Is Not the Number of Qubits, but “Computational Time”

To precisely simulate the reactions of drug candidates, find optimal routes across complex logistics networks, and run quantum algorithms that could threaten existing cryptographic systems, simply having a large number of qubits is not enough. What matters is how long those qubits can sustain computation—and at what error rate.

In other words, the competitiveness of Quantum Computing should no longer be evaluated by “how many physical qubits are available,” but by “how many reliable logical operations can be performed.”

Why the Number of Physical Qubits Does Not Guarantee Performance

Physical qubits are affected by external noise, control errors, measurement errors, and decoherence. As a quantum computation continues, even small errors accumulate, eventually making the result itself difficult to trust.

For example, even a system with 1,000 physical qubits is difficult to use for complex algorithms if it fails to meet the following conditions:

• The two-qubit gate error rate is not sufficiently low
• The qubit state cannot be maintained for long enough
• Errors recur during measurement and control
• Results collapse as circuit depth—in other words, the number of consecutive operations—increases

Therefore, the figure “1,000 qubits” may indicate the scale of a system, but it does not immediately translate into practical computational capability.

The true performance of a quantum computer is revealed not by the number of qubits, but by the effective amount of computation it can complete before errors accumulate.

The Key Metrics Are Logical Qubits and Logical Operations

The concept that emerged to overcome this limitation is the logical qubit. It combines multiple physical qubits and applies quantum error-correction methods, such as surface codes, to create a more stable virtual qubit.

The reason logical qubits matter is simple. Real-world commercial algorithms do not consist of short experimental circuits; they require a very large number of operations to be performed sequentially.

The evaluation criteria are also changing as follows:

| Traditional Perspective | More Important Perspective | |---|---| | How many physical qubits are there? | How many stable logical qubits are there? | | How well does a single gate perform? | How low is the logical error rate in long circuits? | | Was a short demo successfully executed? | How many logical operations were successfully completed? | | Has the number of qubits increased? | Does the error rate actually decrease as the code distance increases? |

Particularly important here is the logical error rate. Even if the physical-qubit error rate is low, long computations can still fail if the error-correction process is not sufficiently effective. Conversely, if a surface code operates reliably below its threshold, adding more physical qubits can enable the system to scale while reducing the logical error rate.

“Computational Time” Determines Applicability

The value of a quantum algorithm is closely tied to circuit depth. Circuit depth refers to the length of a sequence in which multiple quantum gates are applied one after another. Short circuits can be executed to some extent even on today’s NISQ devices, but problems with genuine industrial significance generally require much deeper circuits.

Representative examples include:

• Drug and materials simulation: Accurately calculating the electronic states and reaction pathways of molecules requires a large number of quantum operations and repeated measurements.
• Cryptanalysis: Algorithms for factoring large numbers presuppose large-scale logical qubits and extremely long error-correction operations.
• Complex optimization: Logistics, supply-chain, and financial portfolio problems cannot be solved through quantum computation alone; quantum–classical hybrid iterations must continue reliably.
• Quantum machine learning: Because multiple circuits must be executed repeatedly during training and validation, result reproducibility and error management are critical.

Ultimately, commercially valuable Quantum Computing must go beyond merely “demonstrating a calculation once.” It must be a system capable of completing the required algorithmic depth and returning a reliable answer.

Error Mitigation and Error Correction Are Different

Many quantum systems today use error mitigation techniques that compensate for errors in the results rather than correcting them completely. These methods can be useful for short circuits or limited experiments. They reduce the impact of noise by statistically adjusting the results of multiple runs.

However, error mitigation has clear limitations:

• As circuit depth increases, the number of required repeated executions can rise sharply.
• As the scale of computation grows, the cost and uncertainty of mitigation can increase rapidly.
• Rather than eliminating errors at their source, it reduces their impact during the result-interpretation stage.

By contrast, quantum error correction (QEC) continuously detects and manages errors that occur during computation. When error correction functions properly, it establishes the foundation for maintaining logical states even as computation time increases. This is the key distinction between the error-mitigation-focused NISQ era and the era of fault-tolerant quantum computing.

Questions Investors and Developers Should Ask

When evaluating a quantum computing company or platform, the following questions should come before impressive qubit counts:

• What level of actual logical-qubit performance has been achieved relative to the number of physical qubits?
• Does the logical error rate decrease as the code distance increases?
• Can syndrome data for error correction be processed in real time?
• How deep a circuit can be executed reliably?
• With what level of confidence can logical gates—especially complex operations—be performed?
• Are the quantum processor and HPC/cloud infrastructure integrated efficiently?

The more concrete the answers to these questions, the closer the technology is to becoming a real computing platform rather than merely a research device.

The starting point of quantum advantage is not the moment a company announces more qubits. It is the moment error correction extends computational time and makes it possible to execute deep, complex algorithms reliably from beginning to end. Logical qubits and trustworthy logical operations are the most practical metrics for measuring that transition.