We just published a framework for evaluating logical qubit claims. This blog post explains why you should care, and the thinking behind.
Nobody writing software today thinks about transistor physics. That’s the promise of mature technology: the hard engineering disappears beneath the abstraction layer, and what remains is pure utility. Quantum computing isn’t there yet, but the path is clearer than it has ever been. What’s harder is how to measure progress along it.
Alice & Bob has been building toward fault-tolerant quantum computing (FTQC) since day one. Cat qubits, Alice & Bob’s approach, were chosen precisely because they offer an efficient path to error correction, requiring substantially less physical qubits per logical one than conventional architectures.
Since then, quantum computing has come a long way. The industry has announced many significant milestones, and many logical qubit claims have been made. But these claims do not demonstrate the same thing, and there is no standardized, common definition. Without a common framework, it is difficult to compare them.
At Alice & Bob, we were talking about FTQC as the only path to useful quantum computing before it became industry vocabulary. When Google announced its Willow chip and first logical qubit demonstration in 2024 [1], we were among the first to comment and lay out a set of criteria the result satisfied. Those 3 criteria (breakeven, below-threshold operation, and repeatable error-correction cycles) have still remained in the framework we present today, expanded to five, following the same principles.
This framework, presented in our new memo, Defining the Logical Qubit: Five Criteria to Benchmark Logical Qubit Claims, provides a practical checklist for evaluating any experimental logical qubit.
Why these 5 criteria?
Logical qubits are the building blocks of FTQC. We focus here on memory experiments – single logical qubits, no computation.
These criteria set out the properties we believe necessary for an experimental logical qubit to demonstrate to be considered a truly useful building block of FTQC.
They are modality-agnostic and designed to be accessible, so you do not need a PhD in quantum to apply them.
Here’s a summary:
Criterion 1 — Breakeven: Can you outperform your physical qubits?
The point of error correction is that your logical qubit should be better than the hardware it is built from. The error-correction layer should not introduce more errors than it catches.
You can check this by comparing measured physical and logical lifetimes. The logical one should be longer.
Google Quantum AI demonstrated this with their surface code as mentioned above.
Criterion 2 — Scalable parameters: Can you make it better?
There should be a parameter you can tune, most commonly the code distance, to reach lower logical error rates, but sometimes a physical-level parameter.
In other words: is there a systematic path to scale your error-correction architecture?
Criterion 3 — Sufficient QEC cycles: Have all the errors had time to happen?
Error patterns develop over time and across many correction rounds. If an experiment ends before those patterns have had a chance to emerge, it can report an artificially low error rate.
To avoid that, the experiment should run for at least several multiples of d correction rounds.
Criterion 4 — Performance across all runs: Does it work without cherry-picking?
Post-selection, discarding runs where errors were detected, is not an accurate way to establish a logical error rate and not reproducible while running real algorithms. During a real computation, you cannot throw away the difficult runs.
Criterion 5 (Bonus) — Utility timescales: Does it last long enough to be useful?
This one is harder to check today, which is why it is marked as a bonus.
Utility-scale algorithms, such as Shor’s algorithm for RSA-2048, FeMoco simulation, or Hubbard model calculations, run for hours, days, or even weeks.
At these timescales, rare physical events such as cosmic-ray impacts are suspected to cause non-local errors that conventional QEC may not catch. An experiment that runs for seconds or minutes simply has not been exposed to those error mechanisms.
Do the criteria apply across modalities?
The five criteria are designed to be platform-agnostic, but they are not platform-neutral in their implications.
Each modality has its own specific challenges and open engineering questions still to answer, and may find different criteria easier or harder to satisfy.
Collaboration with HPC: how we get to “real” logical faster
The ultimate objective in building useful logical qubits is to execute utility-scale applications. Every meaningful quantum computation will run inside a classical HPC environment: quantum handles what it does uniquely well, HPC handles the rest.
This makes the HPC community not just an end user of quantum, but an active co-developer of the infrastructure that will make it work.
Three areas where that collaboration can meaningfully accelerate progress, today:
- Buy transitional devices designed for FTQC, even if performance is currently poor when used in NISQ mode.
- Engage research communities advancing FTQC and get them to move from theory to practice.
- Encourage those running NISQ to look at FTQC algorithm design and develop the tooling that they will need for the first computational devices.
Beyond the logical qubit
The finish line is further than what this framework covers. A fault-tolerant quantum computer must compute, not “just” store information, running logical gates and implementing magic states for universal quantum computation. That “computation” part will be the topic of a future report.
Not all announced logical qubits are equal. As we move into the era of early fault-tolerant quantum computing (e-FTQC), the need to have a common language for a useful logical qubit only becomes more pressing.
Our memo is designed to help with that.
References
- [1] Google Quantum AI and Collaborators, “Quantum error correction below the surface code threshold,” Nature, vol. 638, pp. 920–926, 2025. doi: 10.1038/s41586-024-08449-y.
