Ninety-Four news reported “Logical Qubits” Is Not the Same Thing as Ninety-Four REAL and Working Logical Qubits
The distinction between physical qubits, encoded qubits, error-detected states, and genuinely fault-tolerant computational qubits
Abstract
The language of quantum computing has become dangerously compressed. A physical qubit, an encoded quantum degree of freedom, an error-detected code state, an error-corrected state, a fault-tolerant logical gate, and a logical qubit capable of sustained computation are now routinely discussed under the same word: qubit. That linguistic compression produces spectacular headline numbers while obscuring the engineering question that actually matters.
A physical qubit is a hardware system: an ion, atom, spin, superconducting circuit, photon, or other controlled quantum degree of freedom. A logical qubit is not merely a renamed subset of that hardware. In the computationally meaningful sense developed here, it is an encoded quantum degree of freedom that remains coherent while errors are repeatedly detected and corrected and while logical operations—including entangling operations with other logical qubits—are performed over a nontrivial sequence of computation. The logical layer must survive the act of computing. Otherwise, the experiment has demonstrated encoding, error detection, a state-preparation primitive, or a component benchmark rather than the thing that ordinary readers reasonably understand by a working logical quantum computer.
The distinction is especially important when interpreting recent claims involving 94 “logical qubits” on a 98-physical-qubit trapped-ion processor. The underlying paper is technically interesting, but the headline number comes from a high-rate [[k + 2, k, 2]] Iceberg quantum error-detecting code. Distance two permits error detection but not arbitrary single-qubit error correction. The 94-qubit demonstration is a GHZ-state experiment, not a sustained 94-logical-qubit fault-tolerant computation. The same research programme separately reports up to 48 qubits using a distance-four concatenated error-correcting code and, in another 2026 study, end-to-end fault-tolerant execution of QAOA and HHL circuits using the [[7, 1, 3]] Steane code on as many as 12 encoded qubits. Those are materially different achievements and should be described as such.
The thesis of this article is that logical-qubit claims should be evaluated operationally rather than lexically. A working logical computational qubit must demonstrate protected state persistence through repeated rounds of error correction and logical computation. For a pair or larger register, the logical units must be able to interact through protected entangling gates while the code continues to suppress faults. A headline count that merely reports the dimension of an encoded code space does not establish an equal number of robust computational qubits.
Thesis
A physical qubit is a physical carrier of quantum information. An encoded qubit is a mathematical degree of freedom defined inside a larger physical Hilbert space. A working logical computational qubit, however, is an encoded degree of freedom whose quantum state remains usable through repeated error correction and logical computation. Therefore, claims such as “94 logical qubits” must not be interpreted as “94 fault-tolerant computational qubits” unless those 94 encoded units demonstrably perform sustained protected computation. In the 94-qubit Iceberg result, they do not.
Keywords
physical qubit; logical qubit; encoded qubit; quantum error correction; quantum error detection; fault tolerance; Iceberg code; Steane code; code distance; logical error rate; GHZ state; Quantinuum Helios; trapped-ion quantum computing; quantum coherence; logical computation
The word “logical” is doing too much work
The central confusion in contemporary quantum-computing reporting is not difficult to state.
A physical qubit and a logical qubit are not two grades of the same physical object.
A physical qubit is hardware. A logical qubit is an abstraction implemented by hardware.
That would already be enough to require care, but the terminology has become still looser. In quantum coding theory, once a code maps k abstract qubits into a code subspace of n physical qubits, those k degrees of freedom are routinely called logical qubits. That usage is mathematically legitimate. It does not, however, establish that those logical degrees of freedom are useful as robust computational qubits.
The distinction matters because an encoded Hilbert-space dimension is not the same thing as protected computational capacity.
If a code has parameters
[[n, k, d]],
then n is the number of physical qubits, k is the number of encoded logical degrees of freedom, and d is the code distance. The equation tells us how the code is structured. It does not, by itself, tell us whether the machine can execute a long fault-tolerant algorithm on those k degrees of freedom.
This article therefore uses two deliberately different expressions.
Encoded logical qubit means the conventional coding-theory object: a logical degree of freedom represented in a code space.
Working logical computational qubit means something stronger: an encoded quantum degree of freedom that remains coherent and usable while repeated error correction and logical computation are actually performed.
The second is the quantity that matters when someone hears that a machine “has” 94 logical qubits and naturally interprets that statement as a claim about computational capacity.
The two should not be conflated.
Figure 1. “Logical” is not a single engineering milestone. Encoding, error detection, error correction, and sustained fault-tolerant computation are progressively stronger achievements.
What a physical qubit actually is
An ideal qubit is represented by a state
|ψ⟩ = α|0⟩ + β|1⟩,
where
|α|² + |β|² = 1.
The mathematical object lives in a two-dimensional Hilbert space. A physical qubit is an attempt to realise that structure in matter or radiation.
In a trapped-ion computer, the computational basis may be represented by two long-lived internal states of an ion. In a neutral-atom system, hyperfine states may carry the information. In a superconducting architecture, two energy levels of an engineered circuit play the role of |0⟩ and |1⟩. Other architectures use electron or nuclear spins, photons, defects in solids, or different physical systems.
None of these systems is ideal.
Physical qubits are subject to decoherence, imperfect state preparation, control errors, measurement error, leakage, crosstalk, calibration drift, transport error, and correlated noise. A physical operation intended to implement a unitary U is actually some noisy quantum channel approximating U.
That is why the raw physical qubit is not the final computational object.
If a physical qubit has error probability p per relevant operation or interval, then a sufficiently long circuit accumulates errors. Very roughly, if independent faults were the only concern, a circuit of G error opportunities would develop a failure probability scaling like
1 − (1 − p)ᴳ,
which approaches one as G becomes large for fixed p > 0.
The exact expression is architecture-dependent, but the underlying problem is universal: useful computation requires an abstraction whose reliability improves rather than collapses as computation becomes longer.
Quantum error correction is intended to create that abstraction.
Encoding is necessary, but encoding is not enough
Suppose one wants to protect
|ψ⟩ = α|0⟩ + β|1⟩.
An encoding map V sends the one-qubit logical Hilbert space into a larger physical Hilbert space:
V : Hᴸ → Hᴾ.
The logical basis becomes
|0ᴸ⟩ = V|0⟩,
|1ᴸ⟩ = V|1⟩,
so that
|ψᴸ⟩ = α|0ᴸ⟩ + β|1ᴸ⟩.
The point is not duplication in the classical sense. The no-cloning theorem forbids simply making arbitrary independent copies of an unknown quantum state. Instead, the quantum information is distributed into correlations among physical degrees of freedom.
Shor (1995), Steane (1996), Knill and Laflamme (1997), and Gottesman (1997) supplied the conceptual and mathematical foundations for doing this systematically.
Once the state has been encoded, the information is no longer located in one physical qubit.
But that statement alone does not give us a working logical computer.
One can encode a state badly.
One can encode a state and immediately lose it.
One can encode a state and detect certain faults but be unable to repair them.
One can correct errors while the memory sits idle yet fail whenever a computational gate is applied.
One can implement selected fault-tolerant gates but lack a complete universal gate set.
One can prepare an impressive multi-qubit entangled state and then measure it without ever demonstrating sustained computation.
All of those are legitimate experiments. None is equivalent to demonstrating a register of robust logical computational qubits.
This is the distinction that headline counts usually erase.
The logical information is stored in correlations
A simple repetition code illustrates the idea.
Consider
|0ᴸ⟩ = |000⟩ and |1ᴸ⟩ = |111⟩.
An arbitrary state is mapped to
α|000⟩ + β|111⟩.
No individual physical qubit now contains the complete logical state. The relevant information belongs to the joint system.
The three-qubit repetition code is not a complete quantum error-correcting code against arbitrary single-qubit noise because it protects only one error type. General quantum errors include bit-flip-like and phase-flip-like components. Full quantum error correction therefore requires richer code structures.
Nevertheless, the example exposes an essential fact.
A logical qubit is not one especially good atom, electron, ion, photon, or circuit.
It is an encoded degree of freedom realised through structured correlations among physical systems.
That means a register of many genuine logical computational qubits is a demanding many-body control problem. If 94 such units genuinely existed at a mature computational level, they would not merely be 94 labels inside a code-space accounting identity. They would have to be capable of participating in a sequence of logical operations—including entangling interactions between selected logical units—while the physical systems underneath them continued to support error detection, correction, decoding, feed-forward, and state preservation.
The calculation has to happen while the protection remains alive.
Error syndrome is not the logical state
Quantum error correction cannot protect a state by repeatedly measuring the state itself. Doing so would destroy the superposition one is trying to preserve.
Instead, stabilizer codes extract information about errors.
If Sᵢ is a stabilizer generator, a valid code state satisfies
Sᵢ|ψᴸ⟩ = |ψᴸ⟩.
After an error E,
SᵢE|ψᴸ⟩ = ±E|ψᴸ⟩.
The collection of signs obtained from stabilizer measurements constitutes a syndrome.
The crucial point is that the syndrome reveals information about the error class without revealing the encoded amplitudes α and β.
Knill and Laflamme (1997) expressed the general exact-correction condition as
P Eₐ† Eᵦ P = Cₐᵦ P,
where P projects onto the code space and Eₐ, Eᵦ are errors in the correctable set.
A decoder then takes the syndrome information and infers a recovery operation or frame update.
This classical decoder is part of the logical computer. So are ancilla preparation, measurement, reset, feed-forward, scheduling, and the physical gates used to extract syndromes.
A logical qubit is therefore not merely a static mathematical codeword. It is maintained by an active system.
Detection and correction are different achievements
The distinction between quantum error detection (QED) and quantum error correction (QEC) is elementary but absolutely central to the 94-qubit claim.
For a code of distance d, the usual correction capability for arbitrary errors is
t = ⌊(d − 1) / 2⌋.
For d = 2,
t = 0.
A distance-two code can detect a single-qubit error, but it cannot in general determine which correction should be applied to repair an arbitrary single-qubit error.
For d = 3,
t = 1,
so arbitrary single-qubit errors can, in principle, be corrected.
This alone should make a reader stop when a distance-two error-detecting code is converted into a headline count of “logical qubits.”
The encoded degrees of freedom are indeed logical degrees of freedom in the coding-theory sense.
But if the claim being heard is “the machine possesses 94 robust error-corrected computational qubits,” the inference is false.
Error detection tells the system that something went wrong.
Error correction must preserve the computation by determining a consistent recovery or logical-frame update.
Those are not the same capability.
What a pair of working logical qubits would actually have to do
The easiest way to expose the difference is to stop discussing a single idle qubit and ask for two.
Suppose the machine claims to possess two working logical computational qubits L₁ and L₂.
A serious demonstration should be able to prepare them, perform logical single-qubit gates, entangle them through a logical two-qubit operation, continue error correction, perform further logical gates, continue error correction again, and finally read them out.
Schematically,
|ψᴸ¹ᴸ²⟩ → Uᴸ⁽¹⁾ → QEC → Uᴸ¹ᴸ²⁽²⁾ → QEC → Uᴸ⁽³⁾ → QEC → |φᴸ¹ᴸ²⟩.
The sequence matters.
A pair of qubits that can be encoded but cannot interact is not a useful two-qubit processor.
A pair that can interact only by abandoning the code is not fault tolerant.
A pair that survives a single entangling operation but fails after several rounds has not established sustained logical computation.
A pair that produces an attractive result only after discarding most detected-error runs has demonstrated something different from deterministic active correction.
And a pair that survives as memory but cannot implement a computationally sufficient logical gate set remains a memory demonstration rather than a complete computational unit.
The calculation need not solve a commercially valuable problem to establish the physics. It can be a carefully chosen benchmark.
But it must be a calculation, not merely a state.
The logical qubits must remain logical while they compute.
Coherence is not a decorative requirement
The word coherence is sometimes used loosely, but the underlying requirement is straightforward.
Quantum algorithms depend on relative phase and entanglement. If the encoded state loses that information during computation, the machine is no longer implementing the intended quantum process.
A working logical qubit therefore has to preserve the relevant encoded quantum information across the time interval in which computation occurs.
This does not mean the physical qubits themselves never decohere or suffer faults. Quite the opposite. The purpose of the logical layer is to tolerate physical faults without allowing them to become logical failure.
The meaningful quantity is therefore a logical error probability pᴸ, not merely a physical error probability p.
The most important scaling condition is that stronger protection improve logical reliability:
pᴸ(d + Δd) < pᴸ(d).
In below-threshold surface-code models, the logical error is often approximated by a relation of the form
pᴸ ≈ A(p / pₜₕ)^((d + 1) / 2),
for an architecture-dependent constant A, physical error scale p, and threshold pₜₕ (Dennis et al., 2002; Fowler et al., 2012).
The precise expression is not universal. The principle is.
Below threshold,
p < pₜₕ,
and increasing distance should reduce logical failure.
That is what turns redundancy into scalable protection.
Fault tolerance means the protection survives the machinery
Ordinary error correction is not enough because the correction process is itself noisy.
Syndrome extraction uses gates.
Ancilla preparation uses gates.
Measurement is imperfect.
Feed-forward can be wrong.
A fault during correction can propagate.
A fault-tolerant construction is designed so that a sufficiently small number of physical faults cannot spread into an uncorrectable logical fault.
This is why transversal gates, code deformation, lattice surgery, teleportation, magic-state methods, code switching, and related techniques matter.
The Eastin-Knill theorem further establishes that no quantum error-correcting code can supply a universal set of logical gates entirely through transversal operations under the theorem’s assumptions (Eastin & Knill, 2009). Universal logical computation therefore requires additional machinery.
This is precisely where a state-preparation demonstration ceases to be an adequate proxy for a computer.
A computer must transform information.
A logical computer must transform encoded quantum information without surrendering the error protection that makes it logical.
The 94-qubit claim: what the paper actually says
The 2026 Quantinuum Helios work by Dasu et al. is the cleanest contemporary case study because the difference between the technical paper and the headline interpretation can be stated exactly.
Helios has 98 physical trapped-ion qubits.
The high-rate Iceberg QED code used in the 94-qubit experiment has parameters
[[k + 2, k, 2]].
Therefore, for k = 94,
n = k + 2 = 96.
Ninety-six physical qubits can encode 94 logical degrees of freedom in the code-space sense.
The distance is
d = 2.
That is the decisive number.
It is an error-detecting code.
Dasu et al. (2026) explicitly describe the [[k + 2, k, 2]] Iceberg construction as QED and separately describe concatenated distance-four Iceberg codes as QEC. Their abstract reports experiments with between 48 and 94 logical qubits across a mixture of fault-tolerant and partially fault-tolerant benchmarks.
That is already a much more qualified statement than “94 fault-tolerant logical qubits.”
The 94-qubit result is associated with preparation of an encoded GHZ state.
A GHZ state has the form
|GHZ⟩ = (|0⟩⊗ᴺ + |1⟩⊗ᴺ) / √2.
Preparing a 94-way encoded GHZ state is a substantial control experiment.
It is not, however, the same experiment as taking 94 independent error-corrected computational qubits through a long sequence of universal logical gates and QEC cycles.
These claims must remain separate.
Figure 2. The headline number is generated by a high-rate distance-two error-detecting code. The resulting 94 encoded degrees of freedom can form a large encoded GHZ state, but that is not equivalent to demonstrating 94 independent, repeatedly error-corrected, fault-tolerant computational qubits.
Why the physical-to-logical arithmetic should immediately raise a question
There is nothing mathematically impossible about obtaining k = 94 encoded degrees of freedom from n = 96 physical qubits.
High-rate quantum codes are designed precisely to make k / n large.
The mistake is not the code.
The mistake is interpreting coding rate as fault-tolerant computational capacity.
For the Iceberg QED code,
k / n = 94 / 96 ≈ 0.979.
That is an extraordinarily high encoding rate because the code adds only two physical qubits beyond the number of encoded logical degrees of freedom.
But low overhead is being purchased with low distance.
The distance-two construction does not offer the protection expected from a strong error-correcting code.
This trade-off is not a scandal. It is code theory.
What becomes misleading is presenting the resulting k as though it were directly comparable with the count of mature fault-tolerant computational qubits in a much stronger code.
A distance-two encoded degree of freedom and a distance-d fault-tolerant computational qubit are not equivalent engineering resources merely because both are called “logical.”
Entanglement does not settle the question
The 94 logical degrees of freedom were placed into a large entangled state.
That does not convert the demonstration into a 94-qubit fault-tolerant computer.
Entanglement is necessary for general quantum computing, but it is not sufficient.
A Bell pair is entangled.
A GHZ state is entangled.
A cluster state is entangled.
None of those facts alone tells us whether the constituent encoded units can execute a sustained, actively error-corrected universal computation.
The relevant test is not
Were they entangled?
but
Could they remain protected while undergoing a sequence of logical computations?
For 94 genuine working logical qubits, one would want to see subsets of those 94 logical units repeatedly coupled through logical entangling gates, interleaved with QEC, while logical coherence and algorithmic correctness remain under control.
The entanglement must be part of a computational trajectory, not merely the endpoint of state preparation.
The 64-qubit magnetism experiment is also not the same claim
The Dasu et al. (2026) paper also reports a quantum simulation of the three-dimensional XY model using 64 encoded logical qubits.
That sounds much closer to the criterion because an actual application-like circuit is being run.
But the paper itself labels the relevant application benchmark partially fault tolerant.
That phrase matters.
A partially fault-tolerant method deliberately accepts operations that do not satisfy the full fault-tolerance conditions in exchange for lower overhead or higher near-term performance.
Such a result can be scientifically valuable and can outperform an unencoded implementation on a finite benchmark.
It still should not be silently translated into a claim of fully fault-tolerant logical computation.
The technical paper distinguishes FT and pFT because the distinction is real.
Public descriptions should preserve it.
Forty-eight error-corrected qubits is a different result again
The same Helios work reports up to 48 encoded qubits using concatenated Iceberg QEC codes of distance four.
The relevant code family is written as
[[(k₂ + 2)(k₁ + 2), k₂k₁, 4]].
Distance four is stronger than distance two and supports actual error-correction capability.
That is a materially different achievement.
But once again, “48 error-corrected logical qubits” should not automatically be expanded into “48 independently operating, fully fault-tolerant computational qubits executing sustained universal computation.”
The paper contains a collection of component and application benchmarks, some FT and some pFT, with different code constructions used for different purposes.
The correct interpretation is experiment-specific.
The number 48 identifies a code-space scale in a QEC construction.
The computational status has to be established by what those encoded units actually did.
A much stronger 2026 experiment: fault-tolerant algorithm execution
A separate 2026 study by Perlin et al. is more directly relevant to the strict operational definition because it explicitly addresses end-to-end algorithm execution using fault-tolerant components.
The authors use the [[7, 1, 3]] Steane code.
That means one logical qubit is encoded into seven physical qubits and the code has distance three:
[[7, 1, 3]].
Distance three can correct an arbitrary single-qubit Pauli error.
The paper implements fault-tolerant logical components and runs QAOA and HHL circuits. It reports QAOA experiments on five and six logical qubits, circuits up to eight logical qubits with nine logical T gates, and larger 12-logical-qubit QAOA circuits using 97 physical qubits and 2,132 physical two-qubit gates.
This is much closer to the substantive object we should care about.
The encoded qubits are actually used in algorithms.
The algorithms use fault-tolerant gadgets.
Active QEC cycles are incorporated.
The paper examines how adding QEC affects algorithmic performance.
This is not merely a GHZ-state preparation experiment.
But the same paper is explicit about the current limitation.
Its abstract characterises the overall result as near-break-even.
The largest 12-logical-qubit circuits achieve better-than-random performance, not a demonstration that a complex encoded algorithm decisively and systematically outperforms the corresponding physical implementation.
The authors themselves identify execution of complex fault-tolerant algorithmic circuits below break-even as an outstanding challenge.
That qualification is exactly the sort of qualification that should survive into public discussion.
Break-even is not the same as threshold
Two performance concepts are frequently mixed together.
Break-even compares a particular encoded implementation against a relevant unencoded physical implementation.
Very loosely,
p(logical) < p(physical)
for the tested task means the logical implementation has beaten the physical baseline.
Threshold scaling asks a stronger asymptotic question: when the code is strengthened, does logical error continue to decrease?
pᴸ(d + Δd) < pᴸ(d).
One can demonstrate break-even at a fixed code distance without having established scalable threshold behaviour across a code family.
One can also demonstrate below-threshold memory behaviour without having demonstrated below-threshold universal algorithm execution.
These are different milestones.
A serious logical-computing claim should state which one has actually been measured.
Neutral atoms: substantial progress, still not a license to collapse categories
Bluvstein et al. (2026) report a fault-tolerant neutral-atom architecture using up to 448 atoms.
The work is important because it combines several ingredients: repeated QEC, surface-code experiments, logical entangling operations, teleportation, high-rate codes, and mechanisms directed toward universal error-corrected processing.
The authors report below-threshold behaviour in a finite repeated-QEC experiment, including improved logical performance when moving from distance three to distance five in the tested setting.
That is a genuine advance.
The paper also describes deep-circuit protocols with dozens of logical degrees of freedom and hundreds of logical teleportations.
But the paper’s own conclusion is appropriately architectural: these results establish foundations for scalable universal error-corrected processing.
“Foundations for” and “completed large-scale fault-tolerant computer” are not synonyms.
Again, the correct response is not to deny the result.
It is to describe exactly what was achieved.
Why a GHZ state is not a register of independently useful computational qubits
The GHZ example deserves separate treatment because it is intuitively seductive.
For N qubits,
|GHZᴺ⟩ = (|0⟩⊗ᴺ + |1⟩⊗ᴺ) / √2.
This is a highly nonclassical multipartite entangled state.
Demonstrating a large N is impressive.
But a GHZ state occupies a very special two-dimensional subspace of the full 2ᴺ-dimensional Hilbert space.
A register of 94 independently controllable qubits has a state space of dimension
2⁹⁴.
Preparing one particular GHZ superposition does not demonstrate arbitrary control over that full logical state space under fault-tolerant computation.
The experiment demonstrates the ability to prepare and verify a particular large-scale entangled logical state.
That is not nothing.
It is also not the same thing.
This is the exact place where a single number—94—can create a false equivalence.
A true 94-logical-qubit computer would imply far more than a 94-way state
Suppose, for argument, that a laboratory possessed 94 working logical computational qubits under the strict definition used here.
One would expect the machine to support something structurally like
C = Uₘ Qₘ₋₁ Uₘ₋₁ ··· Q₂ U₂ Q₁ U₁,
where:-
each Uᵢ is a layer of logical computation;
-
some Uᵢ contain entangling logical gates among selected pairs or groups;
-
each Qᵢ is an error-correction or protected syndrome-processing stage;
-
the encoded state remains valid through the sequence; and
-
logical error remains bounded at a level compatible with the target computation.
The 94 qubits need not all interact with all others at every step.
They do need to constitute usable logical degrees of freedom that can be routed into computations without abandoning protection.
If a machine can only prepare a single collective 94-way state, that is not the same resource.
If it can run a partially fault-tolerant circuit on 64 of them, that is closer, but still a different claim.
If it can run fully fault-tolerant algorithms on 5, 6, 8, or 12 distance-three encoded qubits with active QEC, that is closer still.
The numbers should therefore not be placed in one column labelled “logical qubits” without qualification.
What “stays coherent” should mean experimentally
A strict definition should not demand metaphysical perfection.
No quantum system stays perfectly coherent forever.
The operational requirement is that the encoded state remain coherent long enough, and with sufficiently low logical error, to execute the intended logical computation.
That has several measurable consequences.
First, logical observables must retain the phase relationships expected from the algorithm.
Second, entanglement created between logical qubits must survive subsequent protected operations.
Third, repeated QEC should reduce rather than amplify logical failure.
Fourth, gate operations should not systematically erase the benefit of encoding.
Fifth, increasing circuit depth should degrade performance according to an error model compatible with scalable suppression rather than simply driving the encoded state rapidly to uselessness.
The phrase “working logical qubit” therefore describes dynamic behaviour.
It cannot be certified by a static code parameter alone.
Post-selection must be made visible
Error-detecting codes frequently use post-selection.
A syndrome indicates that an error occurred, and the experimental run is discarded.
This can improve the fidelity of the accepted dataset.
But it changes the resource accounting.
Suppose a circuit accepts a fraction a of runs. If a declines rapidly with circuit depth, then the apparent fidelity of accepted runs may conceal an exploding sampling cost.
Post-selection is not scientifically illegitimate.
It is simply not the same mechanism as active error correction.
A fault-tolerant computer must eventually continue computing in the presence of ordinary correctable faults rather than repeatedly starting over whenever one is detected.
Therefore any large logical-qubit claim should state clearly whether the protection mechanism is:
detect and discard
or
detect, infer, correct, and continue.
The difference is fundamental.
The physical carrier does matter
In the Helios case, the 98 physical qubits are trapped ¹³⁷Ba⁺ ions.
Each physical qubit is implemented in atomic hyperfine states. The ions are transported between interaction zones, and laser operations implement initialization, measurement, one-qubit gates, and two-qubit gates.
So when 94 encoded logical degrees of freedom are discussed, they are not 94 new physical objects appearing inside the machine.
They are 94 encoded dimensions defined through the joint state of the physical-ion register.
This is why the physical-to-logical mapping has to be understood.
A code can encode many logical degrees of freedom at high rate.
But the resulting logical degrees are not automatically independently robust computational objects.
The amount of protection depends on the code distance, syndrome procedure, decoder, gate construction, noise model, and fault-tolerance protocol.
The difference between “can be entangled” and “can compute while protected”
Two encoded degrees of freedom may be entangled.
That is a necessary capability for universal quantum computation.
But the central test is what happens after the entangling gate.
Can QEC run?
Can another logical gate run?
Can another entangling operation occur?
Can the state survive a sequence of such rounds?
Can the process be repeated at increasing depth without the logical error advantage disappearing?
This is why a pair of logical qubits is such a useful conceptual minimum.
With one qubit, one can hide behind memory and state-preparation demonstrations.
With two, the machine must confront logical interaction.
A credible pair should support at least
prepare → single-logical gates → logical entanglement → QEC → more logical gates → QEC → measurement.
That sequence is recognisably computation.
Scale it to 94 independently usable logical units, and the engineering burden becomes immense.
That is why the distinction cannot be dismissed as pedantry.
A proposed minimum disclosure standard for logical-qubit claims
Any public claim of N logical qubits should disclose, at minimum:
1. Code parameters
[[n, k, d]].
Without d, the word logical is nearly content-free as an engineering claim.
2. Error-detection or error-correction status
Is the code QED or QEC?
Can it merely flag a single-qubit error, or can it identify a recovery class and continue?
3. Logical error rate
What is
pᴸ
for memory, gates, and measurement?
4. Scaling with protection
Does
pᴸ(d + Δd) < pᴸ(d)
hold experimentally?
5. Number of QEC rounds
Was the state protected once, four times, forty times, or thousands of times?
6. Logical gate set
Which single-qubit and multi-qubit logical gates are implemented?
Are they fault tolerant?
7. Computational completeness
Is the demonstrated gate set universal, or is the experiment restricted to a stabilizer or Clifford subset?
8. Entangling computation
Were independent logical qubits actually coupled through logical entangling gates during an algorithm?
9. Post-selection
What fraction of runs were discarded?
10. Application depth
How many logical layers and physical operations were performed?
11. Break-even comparison
Did the encoded circuit outperform the relevant physical circuit?
12. Algorithm-level fault tolerance
Did the error suppression survive the complete computational pipeline rather than isolated components?
With those numbers visible, the reader can understand what “94” actually means.
Without them, the count is mostly a label.
The strict hierarchy that should replace the single word
The field would be easier to understand if claims were placed into a hierarchy.
Physical qubit
A controllable hardware quantum system.
Encoded logical degree of freedom
A qubit represented inside a quantum code space.
Error-detected encoded qubit
An encoded degree of freedom for which selected faults can be identified.
Error-corrected logical qubit
An encoded degree of freedom for which faults in the stated correctable set can be actively handled.
Fault-tolerant logical primitive
A protected preparation, gate, measurement, or QEC component whose faults do not propagate beyond the code’s correction capability.
Working logical computational qubit
An encoded qubit that participates in repeated logical computation while QEC preserves its quantum information.
Fault-tolerant logical processor
A register of such qubits supporting sustained, computationally sufficient logical operations at an error rate and overhead compatible with the intended algorithm.
The 94-qubit Iceberg GHZ result belongs high in the first half of that hierarchy as an impressive large encoded error-detection experiment.
It does not belong at the final level.
That is the entire point.
What the 2026 evidence actually permits us to say
The evidence is neither “nothing has happened” nor “94 fault-tolerant logical qubits now exist.”
Both statements are too crude.
The defensible position is more precise.
First, large encoded code spaces have been demonstrated.
Second, high-rate error-detecting codes can deliver very large k / n.
Third, large encoded entangled states have been prepared.
Fourth, partially fault-tolerant application circuits have been run on dozens of encoded degrees of freedom.
Fifth, stronger error-correcting constructions with lower encoding rate have been demonstrated.
Sixth, small-to-moderate registers using the Steane code have now executed end-to-end algorithmic circuits using fault-tolerant components and active QEC.
Seventh, below-threshold behaviour has been demonstrated in specific finite memory/QEC settings.
Eighth, the field has not thereby demonstrated 94 independently usable, sustained, error-corrected, fault-tolerant computational qubits.
That final distinction is the one headline reporting routinely destroys.
Why this is not semantic gatekeeping
One objection is obvious.
If coding theory calls them logical qubits, why object?
Because language carries implications outside the narrow formal context.
A quantum information theorist reading [[96, 94, 2]] immediately understands that “94 logical qubits” means 94 encoded degrees of freedom at distance two.
A general reader sees “94 logical qubits” and reasonably imagines 94 more reliable qubits available for computation.
Those are not the same interpretation.
The solution is not to rewrite coding theory.
The solution is to report the engineering qualifier with the number.
“94 distance-two error-detected logical degrees of freedom in a GHZ-state benchmark” is accurate.
“94 logical qubits” without qualification invites a much stronger inference.
Similarly:
“12 Steane-encoded qubits executing an end-to-end fault-tolerant QAOA circuit at near-break-even performance” is informative.
“12 fault-tolerant logical qubits” is less informative because it hides the exact benchmark and performance regime.
Precision is not hostility to progress.
It is the only way to measure progress.
The correct question is not “How many logical qubits?”
The correct question is:
How many encoded quantum degrees of freedom can perform the required logical computation, through how many protected rounds, at what logical error rate, under what code distance, with what post-selection, and with what scaling when protection is increased?
That is a longer sentence.
It is also the actual engineering question.
A physical qubit count answers how much quantum hardware is addressable.
A code parameter k answers how many logical degrees of freedom are mathematically encoded.
A working-logical-qubit count should answer how much protected computational capacity exists.
Those three numbers need not be remotely equal.
What ten full logical computational qubits would actually require
The phrase ten logical qubits sounds modest after headlines advertising 48, 64, 94, or more. Under a computational definition, however, ten is already an extremely demanding claim.
Ten working logical computational qubits would mean ten separately addressable encoded quantum degrees of freedom,
L₁, L₂, …, L₁₀,
that can remain protected while participating in a programmable computation. The requirement is not merely that ten code-space variables can be named. Nor is it satisfied by preparing one ten-party entangled state and immediately measuring it. The ten encoded units must survive a sequence in which logical gates, entangling operations, syndrome extraction, decoding, correction or frame updates, and further gates occur repeatedly.
A representative structure would be
|ψᴸ¹…ᴸ¹⁰⟩ → Uᴸ⁽¹⁾ → QEC → Uᴸ⁽²⁾ → QEC → ··· → Uᴸ⁽ᵐ⁾ → |φᴸ¹…ᴸ¹⁰⟩.
The layers Uᴸ⁽ⁱ⁾ must include more than independent single-qubit rotations. At least some must contain protected two-logical-qubit entangling gates, because a register of ten logical qubits that cannot execute interactions among them is not a ten-qubit general-purpose logical processor.
A useful experimental test would deliberately change the logical interaction graph over time. One layer might contain
CNOT(L₁, L₂), CNOT(L₃, L₇), CNOT(L₅, L₉),
followed by error correction. A later layer might contain
CNOT(L₂, L₆), CNOT(L₄, L₁₀),
followed by further error correction, logical rotations, non-Clifford operations, and another interaction pattern.
The important word is programmable. The ten logical qubits need not all be maximally entangled with one another at every instant. That would be neither necessary nor generally desirable. They must instead support whatever logical entanglement graph the algorithm demands, while the protection mechanism remains active.
That is qualitatively different from a GHZ experiment. A ten-qubit GHZ state,
(|0000000000⟩ + |1111111111⟩) / √2,
is a particular highly entangled state. Its preparation can test important control and fidelity properties. But it is not evidence that ten independently programmable logical qubits can execute an extended quantum circuit. A GHZ state proves a state-preparation capability. A logical processor must prove a computational trajectory.
For ten full logical computational qubits, the relevant experimental question is therefore not “can ten encoded degrees of freedom be entangled?” It is:
Can ten encoded degrees of freedom be repeatedly and selectively entangled, transformed, corrected, disentangled, re-entangled in different patterns, and measured while the logical error remains suppressed throughout the computation?
That is a much stronger claim.
Distance three is a beginning, not an endpoint
Code distance provides one of the cleanest ways of seeing how far the current hardware remains from the reliability regime implied by large-scale fault-tolerant computation.
For a code of distance d, the ideal correction capability against arbitrary errors is
t = ⌊(d − 1) / 2⌋.
Thus,
d = 2 ⇒ t = 0,
d = 3 ⇒ t = 1,
d = 5 ⇒ t = 2,
d = 7 ⇒ t = 3.
The first point is immediate. A distance-two code is not a general single-error-correcting code. That is why the 94-qubit Iceberg QED figure cannot be treated as 94 robust computational logical qubits.
Distance three is qualitatively stronger. The [[7, 1, 3]] Steane code used by Perlin et al. (2026) can correct one arbitrary physical-qubit error in the ideal code model, and the 2026 experiments genuinely use fault-tolerant gadgets and active QEC to execute QAOA and HHL circuits. That is real progress. It is also precisely why the paper’s own description of the result as near break-even matters.
A distance-three experiment can establish that fault-tolerant algorithm execution is physically possible. It does not establish that the system has entered the reliability regime required for long, useful computation.
The distinction is numerical as well as conceptual.
If a logical computation presents G significant opportunities for logical failure and the tolerated total failure probability is P(fail), then a crude first-order requirement is
pᴸ ≪ P(fail) / G.
For G = 10⁶ and an overall failure budget of one per cent,
pᴸ ≪ 10⁻⁸
per relevant logical operation is already required at the level of an order-of-magnitude estimate.
For G = 10⁹, the corresponding scale becomes approximately
pᴸ ≪ 10⁻¹¹.
The exact engineering budget is more complicated because different operations have different error rates and because faults can be correlated. But the scale of the requirement is the point.
Current experiments are not separated from those targets by a small incremental improvement. They are separated by many orders of magnitude in logical reliability, while simultaneously needing to scale the number of logical qubits, the gate set, the decoder, the syndrome system, the routing architecture, and the physical-qubit inventory.
The experimental distance record is not the computational distance record
This distinction must be stated carefully because impressive code-distance numbers are easy to misread.
The mathematics of codes with d = 15, d = 21, d = 25, and larger certainly exists. Such codes can be defined, analysed, simulated, and used in resource estimates. It would therefore be wrong to claim that the field has not developed the mathematics for these distances.
The gap is experimental.
Google Quantum AI’s below-threshold surface-code work demonstrated a distance-seven surface-code memory using 101 physical qubits and reported a logical error of approximately 0.143% per error-correction cycle, with a suppression factor of about 2.14 when the code distance increased by two (Google Quantum AI and Collaborators, 2025). The same programme ran repetition codes to much larger nominal distances, including distance 29, but a repetition code protects only a restricted error channel. It is not a distance-29 general quantum logical qubit.
That qualification is decisive:
d = 29 repetition code ≠ d = 29 full quantum error-correcting logical qubit.
A full surface-code logical memory at d = 7 is already an important experimental achievement. But a memory is not yet a universal logical processor, and d = 7 is far below the distances routinely appearing in resource estimates for long fault-tolerant calculations.
Recent papers discussing larger-distance logical gates make the same gap visible from the opposite direction. Hirai et al. (2026), for example, analyse a logical S gate for the surface code and numerically evaluate fault distances and logical error rates at larger distances. That work is a simulation and circuit-design result. It is not a hardware demonstration of a distance-15 or distance-21 logical processor.
The accurate statement is therefore:
THE MATHEMATICS EXTENDS WELL BEYOND d = 15; THE EXPERIMENTAL FULL-QEC COMPUTATION DOES NOT.
This matters because theoretical distance is often silently imported into discussions of present-day hardware. A resource estimate that says an application might work at d = 15, d = 21, or d = 31 does not mean a laboratory has built and operated such a logical qubit through a sustained universal computation.
Why distance must be demonstrated under computational load
Even a high-distance memory would not settle the issue.
The logical error rate must remain suppressed while gates are executed. A memory experiment principally tests the protected identity operation,
Iᴸ.
A computer must implement a sequence containing nontrivial logical operations,
Hᴸ, Sᴸ, Tᴸ, CNOTᴸ,
or an equivalent universal logical gate set.
The hardware burden rises immediately because every logical operation creates new fault locations. An entangling gate can propagate faults between code blocks. A non-Clifford operation generally requires additional machinery. Syndrome extraction has to continue. Ancillas have to be prepared and verified. Measurements and classical feed-forward must remain timely. Leakage has to be removed. Decoding latency must remain below the point at which waiting creates more errors than the decoder removes.
Consequently, the relevant inequality is not merely
pᴸ,memory(d + 2) < pᴸ,memory(d).
For a computational claim, one wants evidence that the suppression survives the operations that constitute the actual algorithm:
pᴸ,compute(d + 2) < pᴸ,compute(d).
That is a much harder experimental standard.
A system can be below threshold as a memory and still lose the advantage when a dense sequence of logical gates is introduced. It can perform one fault-tolerant gate well and still fail at the gate density of a long algorithm. It can demonstrate a universal set of logical primitives and still lack the aggregate fidelity required when thousands or millions of those primitives are composed.
This is one reason a statement such as “we have a logical qubit” is inadequate. The relevant question is: logical under what workload?
Ten full logical qubits would require a systems demonstration
Consider what must work simultaneously for a ten-logical-qubit processor.
There must be ten encoded data units. There must be enough additional physical qubits or other degrees of freedom for syndrome extraction, ancillas, routing, state preparation, and replacement. The decoder must process a growing syndrome stream. The control system must schedule gates without introducing correlated errors that defeat the code assumptions. Logical two-qubit gates must connect the required pairs. Non-Clifford resources must be supplied. Measurement and reset must occur without corrupting neighbouring encoded states. QEC must continue through all of it.
The experiment should then be repeated at sufficient depth to establish that the register is not merely surviving a short demonstration circuit.
There is no theorem stating that exactly one thousand QEC rounds or one thousand logical gates is the threshold between “demonstration” and “computer.” A fixed round count would be artificial. But a convincing claim requires enough depth to expose the steady-state logical error process rather than only the transient behaviour of preparation and readout.
A ten-qubit circuit with a few protected gates can establish a primitive.
A ten-qubit circuit with hundreds or thousands of logical operations, repeated QEC, changing entanglement topology, non-Clifford operations, and a measured total failure probability consistent with the component-level logical error model begins to establish a computational substrate.
The difference is not one of taste. It is the distinction between showing that components can be assembled and showing that the assembled machine retains the property for which the components were introduced.
The entanglement requirement is often misunderstood
It would also be incorrect to say that all physical constituents of ten logical qubits must remain globally entangled with one another at every moment.
That is not how an algorithmic register should be judged.
Each logical qubit is itself encoded in correlations over its physical support. Two-logical-qubit gates must then be capable of creating controlled logical entanglement between code blocks or encoded degrees of freedom. Over a circuit, the entanglement graph changes.
The strong requirement is therefore
PROGRAMMABLE LOGICAL ENTANGLEMENT WHILE ACTIVE QEC CONTINUES.
For a genuine ten-logical-qubit processor, arbitrary required pairs among
L₁, …, L₁₀
must be able to participate in protected interactions according to the compiled circuit. That may occur through direct transversal operations, teleportation, lattice surgery, code deformation, ion transport, or another architecture-specific mechanism. The physics differs by platform. The computational requirement does not.
This is why a 94-way encoded GHZ state does not answer the relevant question. It proves that a large correlated state can be produced inside the chosen encoding. It does not prove arbitrary, repeated, fault-tolerant logical connectivity among 94 independent computational units.
The orders-of-magnitude problem
The most sobering comparison comes from error rates.
Google Quantum AI’s 2025 surface-code memory achieved approximately
1.43 × 10⁻³
logical error per QEC cycle at distance seven (Google Quantum AI and Collaborators, 2025).
That is historically important because it demonstrates genuine below-threshold suppression and beats the lifetime of the best physical qubit in the comparison used by the experiment. But an error probability of order 10⁻³ per cycle is not an algorithmic error probability of order 10⁻¹⁰, 10⁻¹², or lower.
The same Nature paper explicitly motivates QEC by noting that many applications require effective error probabilities enormously below present physical entangling-gate error rates (Google Quantum AI and Collaborators, 2025).
The required improvement is therefore not simply “another factor of two.” If the target is 10⁻¹⁰ and the demonstrated logical-cycle error is around 10⁻³, the gap is roughly seven orders of magnitude in error probability before considering the additional burden of universal logical gates. A 10⁻¹² target would represent roughly nine orders of magnitude.
Those numbers should not be converted directly into a claim that a particular future machine requires exactly seven or nine additional code-distance increments. The mapping depends on the measured suppression factor and whether that factor remains stable at larger distance. Correlated errors can impose floors. Gate density can change the effective threshold. Decoder behaviour can change with scale. Fabrication yield, leakage, thermal events, cosmic rays, control errors, and crosstalk can all alter the extrapolation.
But that uncertainty strengthens rather than weakens the conclusion: the required large-distance operating regime has not yet been experimentally validated. AT ALL.
Correlated errors are a direct threat to large-distance extrapolation
The attractive asymptotic promise of QEC assumes that sufficiently dangerous high-weight faults become exponentially less likely as distance increases.
Real hardware can violate the simplest independent-noise assumptions.
Google’s large repetition-code experiments observed rare correlated error events after billions of cycles (Google Quantum AI and Collaborators, 2025). Such events are important precisely because a large code is designed around the expectation that simultaneous high-weight errors are exceptionally rare.
If a single physical disturbance can affect many physical qubits together, then increasing d does not automatically buy the suppression predicted by an independent-error model.
This is one of the reasons extrapolating from d = 3, 5, 7 to d = 15, 21, 31 is not a matter of drawing a straight line on a logarithmic graph.
The device has to demonstrate that its noise remains sufficiently local and sufficiently well modelled as the machine grows.
The decoder also has to scale
A working logical processor is partly a classical real-time inference machine.
Every QEC cycle produces syndrome information. As code distance, qubit number, and circuit depth increase, the decoder must process that information with sufficiently low latency and sufficiently high accuracy.
Google’s distance-five real-time decoding experiment running for up to one million cycles is important because it demonstrates that sustained classical feedback can be incorporated into the QEC loop (Google Quantum AI and Collaborators, 2025).
But scaling from one or a few logical memories to ten, one hundred, or one thousand interacting logical qubits changes the decoding problem substantially. The classical system must keep up with a larger syndrome volume while the quantum hardware continues operating.
A logical qubit whose decoder cannot keep pace with the physical clock is not a scalable logical computational qubit.
The physical-qubit overhead has not disappeared
The distance also determines physical-resource requirements.
For a rotated surface code, the number of data qubits for one logical patch scales approximately as
d²,
with additional measurement qubits and routing resources. The precise total depends on layout and architecture, but the essential scaling is quadratic in distance for each patch before factories, buses, ancillas, spare capacity, and logical operations are counted.
Thus moving from d = 3 to d = 15 is not a fivefold increase in physical cost. At the level of data-area scaling, it is approximately
15² / 3² = 25
times the area per logical patch.
Moving from d = 3 to d = 21 gives
21² / 3² = 49.
And that still says nothing about the additional space-time overhead required for logical operations, routing, magic-state distillation or equivalent non-Clifford resources, and fault-tolerant state preparation.
This is why the statement “we already have 94 logical qubits” can create a profoundly wrong intuition about scale. If those 94 are obtained through a d = 2 high-rate QED code, their physical cost and protection level are not remotely comparable with 94 high-distance fault-tolerant computational patches.
The same word is being used for fundamentally different engineering resources.
Near break-even is not near a practical machine
The 2026 Perlin et al. result is useful precisely because it is stronger than a state-preparation result. It executes end-to-end error-corrected QAOA and HHL circuits using fault-tolerant components. It reaches up to 12 Steane-encoded logical qubits in the largest QAOA experiments and uses active QEC.
That is an important scientific milestone.
It also provides a useful calibration point for what has not yet been achieved.
The paper describes the overall performance as near break-even. Up to eight logical qubits and nine logical T gates perform similarly to unencoded circuits. The largest 12-logical-qubit circuits, involving 97 physical qubits and 2,132 physical two-qubit gates, remain better than random rather than demonstrating a large, sustained, below-break-even advantage over the unencoded computation (Perlin et al., 2026).
“Near break-even” means the field is reaching the point at which the overhead of protecting the quantum information can approximately compensate for the additional errors introduced by the protection machinery in selected finite circuits.
That is not the same as having a logical computer with enough error margin to execute millions or billions of logical operations.
Break-even is the starting line for useful error correction, not the destination.
Why we are not slightly short of large-scale fault tolerance
It is important to state the conclusion without exaggerating it in either direction.
The experiments are real. The progress is real. Below-threshold logical memories are real. Fault-tolerant logical primitives are real. Small end-to-end fault-tolerant algorithms are now real.
But these achievements do not mean the remaining problem is a modest engineering scale-up.
A practical fault-tolerant quantum computer would have to satisfy several requirements simultaneously that have so far mostly been demonstrated separately or at small scale:-
Large code distance. The full quantum code must operate at a distance sufficient to reach the required logical error budget, not merely d = 2, 3, 5, or 7.
-
Below-threshold scaling. Increasing distance must continue to suppress logical error on the actual hardware.
-
Computational, not merely memory, suppression. The suppression must survive dense logical gate sequences.
-
Universal logical operations. Clifford and non-Clifford operations must operate fault tolerantly with sufficiently low aggregate error.
-
Programmable logical entanglement. Logical qubits must interact according to changing algorithmic graphs rather than only through prepared collective states.
-
Repeated active QEC. Correction must continue through the computation rather than relying primarily on detection and discarded runs.
-
Low correlated-error floor. Rare physical events must not destroy the exponential advantage of increasing distance.
-
Real-time decoding at scale. Classical inference and feedback must keep pace with the quantum cycle across a large processor.
-
Resource-feasible overhead. The physical-qubit, space, time, and control overhead must remain compatible with the target algorithm.
-
Algorithm-level error budget. The complete logical circuit must achieve the total failure probability required by the application, not merely show a component fidelity above a benchmark.
None of these requirements is optional in a large-scale fault-tolerant machine.
Current experiments demonstrate important subsets of them. No current experiment demonstrates all of them simultaneously at the scale implied by a robust ten-logical-qubit processor operating at the logical error rates required for long computation, much less at the scale suggested by unqualified claims of dozens of mature logical qubits.
That is why the distance between present demonstrations and large-scale fault-tolerant computation should not be described as slight.
It is a multidimensional gap: distance, error rate, logical gate fidelity, QEC depth, entangling connectivity, decoder throughput, correlated-noise control, physical overhead, and algorithmic scale all have to improve together.
The field has crossed several important proof-of-principle boundaries. It has not crossed the systems-engineering boundary that turns those proofs into a large, sustained logical computer.
Conclusion
A physical qubit is straightforward to define conceptually: it is a physical quantum system chosen to represent a two-level computational degree of freedom.
A logical qubit is more difficult because the word is used at two levels.
In coding theory, a logical qubit is an encoded degree of freedom in a code space.
In the stronger computational sense relevant to claims about working quantum computers, a logical qubit should mean an encoded quantum degree of freedom that remains coherent and usable while logical operations and repeated error correction are performed.
That stronger definition is the one that prevents a code-space count from masquerading as a computational-capacity count.
The 94-qubit Helios result is the decisive example.
The relevant Iceberg construction is
[[k + 2, k, 2]].
At k = 94, 96 physical qubits encode 94 logical degrees of freedom.
But
d = 2.
It is an error-detecting code.
The 94-qubit experiment prepares a large encoded GHZ state.
It does not demonstrate 94 independently operating, repeatedly error-corrected, fault-tolerant computational qubits.
The same research programme separately demonstrates 48 qubits in a stronger distance-four QEC construction and, in another study, end-to-end fault-tolerant algorithm execution on much smaller Steane-encoded registers, reaching up to 12 logical qubits in the largest QAOA circuits. Those experiments are not interchangeable. Their different numbers measure different technical achievements.
A pair of working logical computational qubits should be able to do something recognisably computational: remain encoded, undergo logical operations, become entangled through a logical gate, pass through error correction, undergo further computation, and remain usable at the end.
Scale that criterion to 94 and the claim becomes enormously stronger.
That is why “94 logical qubits” cannot be treated as self-explanatory.
The important question is not whether the code contains 94 mathematical logical degrees of freedom.
It does.
The important question is whether 94 such units have been demonstrated as a protected computational register.
They have not.
Until the qualifier is supplied, the number describes the code more clearly than it describes the computer.
The same discipline must be applied to future claims. Ten genuinely working logical computational qubits would already require repeated programmable logical entanglement, active QEC, a computationally sufficient fault-tolerant gate set, and logical error suppression that survives depth. The present experimental frontier remains at low full-QEC code distances and near-break-even algorithmic demonstrations. Distances such as 15, 21, or higher belong primarily to mathematical analysis, simulation, and resource estimation rather than sustained full-QEC hardware computation. The gap between those regimes is not semantic and it is not small. It is the central unresolved engineering problem.
References
Aharonov, D., & Ben-Or, M. (2008). Fault-tolerant quantum computation with constant error rate. SIAM Journal on Computing, 38(4), 1207–1282. https://doi.org/10.1137/S0097539799359385
Bluvstein, D., Geim, A. A., Li, S. H., Evered, S. J., Bonilla Ataides, J. P., Baranes, G., Gu, A., Manovitz, T., Xu, M., Kalinowski, M., Majidy, S., Kokail, C., Maskara, N., Trapp, E. C., Stewart, L. M., Hollerith, S., Zhou, H., Gullans, M. J., Yelin, S. F., ... Lukin, M. D. (2026). A fault-tolerant neutral-atom architecture for universal quantum computation. Nature, 649, 39–46. https://doi.org/10.1038/s41586-025-09848-5
Dasu, S., DeCross, M., Guo, A. Y., Lavasani, A., Behrends, J., Benhemou, A., Chen, Y.-H., Mayer, K., Self, C. N., Simsek, S., Srivastava, B., Allman, M. S., Arkinstall, J., Bohnet, J. G., Burdick, N. Q., Campora, J. P., III, Chernoguzov, A., Cooper, S. F., Delaney, R. D., Dreiling, J. M., ... Amaro, D. (2026). Computing with many encoded logical qubits beyond break-even [Preprint]. arXiv. https://doi.org/10.48550/arXiv.2602.22211
Dennis, E., Kitaev, A., Landahl, A., & Preskill, J. (2002). Topological quantum memory. Journal of Mathematical Physics, 43(9), 4452–4505. https://doi.org/10.1063/1.1499754
Eastin, B., & Knill, E. (2009). Restrictions on transversal encoded quantum gate sets. Physical Review Letters, 102(11), 110502. https://doi.org/10.1103/PhysRevLett.102.110502
Fowler, A. G., Mariantoni, M., Martinis, J. M., & Cleland, A. N. (2012). Surface codes: Towards practical large-scale quantum computation. Physical Review A, 86(3), 032324. https://doi.org/10.1103/PhysRevA.86.032324
Google Quantum AI and Collaborators. (2025). Quantum error correction below the surface code threshold. Nature, 638, 920–926. https://doi.org/10.1038/s41586-024-08449-y
Hirai, Y., Ikari, S., Ueno, Y., & Suzuki, Y. (2026). A 2d × d × d spacetime volume implementation of a logical S gate in the surface code [Preprint]. arXiv. https://doi.org/10.48550/arXiv.2604.13632
Gottesman, D. (1997). Stabilizer codes and quantum error correction [Doctoral dissertation, California Institute of Technology]. https://doi.org/10.48550/arXiv.quant-ph/9705052
Knill, E., & Laflamme, R. (1997). Theory of quantum error-correcting codes. Physical Review A, 55(2), 900–911. https://doi.org/10.1103/PhysRevA.55.900
Perlin, M. A., He, Z., Armenakas, A. A., Andres-Martinez, P., Hao, T., Herman, D., Jin, Y., Mayer, K., Self, C., Amaro, D., Ryan-Anderson, C., & Shaydulin, R. (2026). Fault-tolerant execution of error-corrected quantum algorithms [Preprint]. arXiv. https://doi.org/10.48550/arXiv.2603.04584
Preskill, J. (1998). Reliable quantum computers. Proceedings of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences, 454(1969), 385–410. https://doi.org/10.1098/rspa.1998.0167
Shor, P. W. (1995). Scheme for reducing decoherence in quantum computer memory. Physical Review A, 52(4), R2493–R2496. https://doi.org/10.1103/PhysRevA.52.R2493
Steane, A. M. (1996). Error correcting codes in quantum theory. Physical Review Letters, 77(5), 793–797. https://doi.org/10.1103/PhysRevLett.77.793