Carousel crash course on fault tolerance

Fault tolerance is a difficult topic to get across. It’s technical, layered, and easy to lose track of the main thread. We started using carousels to explain fault tolerance because they gave us a way to break the subject into small, self-contained pieces, while still leaving space for some depth. Each one focuses on a single idea, but when read together they start to form a picture of how the pieces fit.

In this post, we’ve pulled together all of our carousels on fault tolerance into one place. You can think of it as a compact mini-curriculum that lets you explore the key concepts that make quantum fault tolerance so challenging yet remarkably possible.

We’re also enhancing the carousels with companion posts that give more context. We’ll link them below as they go live.

Here’s what you’ll find:

The quest for logical qubits: Many top QC teams are working on building logical qubits. Why?
How to Read a Surface Code Diagram: Understanding the components and what they mean for error correction.
The logic behind logical qubits: How logical qubits get us to near-perfect quantum computing.
Quantum Fault Tolerance Thresholds: Your simple guide to interpreting threshold plots.
Hardware doesn’t need to be perfect: But we need to understand all its imperfections to make quantum fault tolerance work.
Not all errors are equal: Different types of errors shape quantum error correction thresholds in different ways.
Shifting error thresholds: Using threshold surfaces to navigate multiple interacting imperfections.
99% gate fidelity: Is that all we need? Or is there more to the story?
Why simulating FTQC is so hard: And how Plaquette + NVIDIA are changing that.
What makes a fault-tolerant quantum computer possible? The four key components of a robust architecture and how they affect error correction.
Do you really need 10000 physical qubits? Estimating overheads in Fault-Tolerant Quantum Computing.

Together, these eleven carousels give you a crash course in one of the central problems of quantum computing: how to make imperfect devices act as if they were nearly perfect.

The quest for logical qubits

Introduction: let's look at applications where quantum computers are expected to really shine

Table of quantum applications and gate counts, from 10 million to 10 trillion — these need very large numbers of gates

Flowchart: more gates lead to more computation time, more errors accumulate — error probability must be really low

High vs low error rates: 1 error per 10 gates causes incorrect output; 1 per 1000 gates gives correct output

Rule of thumb: for reliable computation, the error rate must be lower than 1 divided by the number of gates

Table of required error rates per application, from less than 1 in 10 million to less than 1 in 10 trillion

Today's quantum computers: requirement is less than 1/10M, reality is 1/1000 — a 10,000x improvement is needed

Enter logical qubits: encoding 1 qubit of information into many physical qubits to protect against errors

Logical qubits enable deep circuits with billions of gates, needed for reliable and useful quantum computers

How Plaquette helps: analyzes error thresholds across qubit types like bit flip, dephasing, leakage, and erasure

Learn more about Plaquette: contact QC Design on LinkedIn or at qc.design

How to Read a Surface Code Diagram

A 3x3 grid of nine data qubits (black dots) used to encode one qubit of information

Data qubits on a grid with lightning bolt errors; measuring them directly destroys the information

Orange measurement qubits added between black data qubits to measure errors indirectly

Blue square around four data qubits shows a bit flip error check on four adjacent qubits

Blue semicircle on the grid boundary shows a bit flip error check on two adjacent data qubits

Gray square and gray semicircle indicate phase flip error checks on four or two adjacent qubits

Complete 3x3 surface code diagram with legend: data qubits, measurement qubits, bit flip and phase flip checks

Each QEC code has its own diagram showing qubit connectivity and range of interactions

Plaquette lets users specify qubit arrangements and interactions, with surface code and color code examples

Plaquette lets users construct custom codes by specifying X and Z stabilizers and logical operators

Plaquette compiles circuits and calculates error thresholds for different codes automatically

Closing slide: Learn more about Plaquette at qc.design or contact QC Design on LinkedIn

The logic behind logical qubits

Computation isn't perfect: encoding one qubit of information into a logical qubit using a grid of physical qubits

Can we always fix errors? A qubit grid struck by lightning bolts representing noise that overwhelms the encoding

Bigger is better but only sometimes: larger encodings offer better protection only if noise is below the fault tolerance threshold

Above the threshold the logical qubit fails: graph showing logical error rising with encoding size when noise is too high

Below the threshold the logical qubit works: graph showing logical error dropping as encoding size grows

Now we can get as low logical errors as we like: logical error rate decreases exponentially below the threshold

Plaquette makes it easy to study thresholds: bar chart comparing thresholds for bit flip, dephasing, leakage, and erasure errors

Quantum Fault Tolerance Threshold Plots

Title slide: Quantum fault tolerance thresholds -- your simple guide to interpreting threshold plots, with a sample plot

Three important ideas: 1. Hardware imperfections, 2. Logical qubit errors, 3. Logical qubit size

Hardware imperfections: photos illustrating depolarizing noise, leakage, scattering, and optical loss in qubits

Threshold plot with labeled x-axis: any hardware imperfection can be put on the x-axis

Threshold plot with labeled y-axis: the effective error rate for logical qubits goes on the y-axis

Logical qubit errors: physical qubit errors propagate to the logical level, and the logical error rate is what matters

Logical qubit size: larger logical qubits use more physical qubits, and different sizes have different performance

Threshold plot with qubit grid diagrams showing code sizes 3, 5, and 7 each produce a distinct curve

Question slide: So why is it called a threshold plot?

The fault tolerance threshold: the crossing point where all code-size curves meet on the plot

Above threshold: increasing logical qubit size makes the error rate worse (size up, logical errors up)

Below threshold: increasing logical qubit size reduces errors -- that's where the magic happens

Key takeaway: the fault tolerance threshold is where a quantum system can correct errors faster than they occur

Plaquette makes threshold plots easy: diagram showing a qubit lattice processed by Plaquette into a threshold plot

Hardware doesn't need to be perfect

The fault tolerance threshold: the point at which a quantum system can correct errors faster than they occur

Threshold plot: logical error rate vs hardware imperfection, with arrow showing where code-size curves cross

Above threshold: error rate worsens as logical qubit size increases — bigger size means more logical errors

Below threshold: error rate improves as logical qubit size increases — bigger size means fewer logical errors

Hardware imperfections come in many forms: depolarizing noise, leakage, scattering, optical loss, and more

And we need to understand them all — every imperfection must be accounted for

Threshold plots for four imperfection types: depolarizing noise, mitigated leakage, scattering, and optical loss

Hardware teams must stay below the threshold for all imperfections — but calculating thresholds is really hard

Plaquette simplifies threshold calculations: diagram showing qubit lattice input and thresholds per imperfection output

Not all errors are equal

Quantum computers must stay below the fault tolerance threshold, which limits how much error a system can handle

What kinds of errors can happen inside a quantum computer, and how are they different?

Errors on data qubits: depolarizing noise scrambles data qubits, with best codes handling up to ~19% error rate

Measurement error: errors when measuring qubits bring the threshold down from ~19% to 3%

Errors on ancilla qubits: helper qubits used for error correction can also pick up errors affecting computation

Gate error: errors on gates between qubits give the circuit noise model a threshold of ~1%

Erasure error: losing all information from a known qubit allows higher thresholds of 25%-50%

Leakage error: qubits leaking outside the 0/1 basis has no threshold, requiring leakage mitigation

Different systems: superconducting and photonic platforms have unique errors like optical loss and fusion failure

Four threshold plots comparing depolarizing noise, mitigated leakage, scattering, and optical loss error models

Different error correction codes like surface code and color code are designed for different types of imperfections

Plaquette simplifies threshold calculations, mapping codes to their thresholds for different error types

Shifting error thresholds

Previously: an error threshold tells us how much error a system can handle before quantum error correction fails

Four threshold plots for different imperfections: depolarizing noise, mitigated leakage, scattering, and optical loss

Key insight: thresholds for different imperfections are not independent of each other

Multiple imperfections: quantum circuit with errors striking gates, measurements, and leakage simultaneously

Two threshold plots for imperfections A and B, each showing a correctable region to the left of the threshold

2D plot placing individual thresholds for imperfection A and B on separate axes when only one is present

Threshold curve on a 2D plot: correctable region in bottom-left, non-correctable region in top-right

Two error correction codes compared: Code 2 has a larger correctable region than Code 1 on the threshold surface

Hyper-surfaces: with more than two imperfections, thresholds form higher-dimensional surfaces

What does this mean: error codes must be tailored to each hardware platform's unique error landscape

Example: hardware with high erasure errors may need a color code, while measurement errors suit a surface code

Understanding how thresholds shift under multiple imperfections is key to designing fault-tolerant quantum systems

Plaquette simplifies threshold calculations for multiple error types, mapping imperfections to correctable regions

99% gate fidelity

Introduction: we need 99% fidelity for fault-tolerant quantum computing, but where does this number come from?

Origin: 99% is a widely-accepted rule of thumb based on research and simulations, shown with four academic papers

What it means: once two-qubit gates reach 99% fidelity, fault tolerance becomes feasible — but it's only part of the story

The 99% rule only considered superconducting qubits and the surface code error correction scheme

To advance quantum computing we must explore new architectures and determine their thresholds

Four components of a fault-tolerant architecture: error correction code, error decoding, qubit definition, and qubit control

Threshold plots for different error models: depolarizing noise, mitigated leakage, scattering, and optical loss

Bar chart of fault tolerance thresholds by error type: dephasing, mitigated leakage, scattering, and optical loss

The goal is to stay below fault-tolerance thresholds for all error types, but calculating them is really hard

Plaquette simplifies threshold calculations, comparing two architectures with per-error-type threshold bar charts

Why simulating FTQC is so hard

Simulating quantum circuits is easy under simplifying assumptions like stabilizer circuits and Pauli noise

Real quantum systems need full state evolution modeling, including coherence loss and gate imperfections

Full-state simulations require massive computational resources

Bar chart showing memory grows exponentially with qubit count: 8 MB at 20 qubits to 8 GB at 30 qubits

Qudits with extra energy levels and gate errors make simulation even harder, needing ~8000 GB for 20 qudits

Traditional CPU-based methods hit a limit: Monte Carlo simulators max out around 60 qubits with 120 GB RAM

Plaquette + NVIDIA cuQuantum provide full-state evolution at scale

GPU acceleration enables Plaquette to simulate 400+ qubits on an RTX 4000 with 20 GB memory

Surface code comparison: CPU handles distance-3 (17 qubits), GPU enables distance-5+ (49 qubits)

Three benefits for hardware teams: larger simulations, full-state error analysis, and 180x speedups

What makes a fault-tolerant quantum computer possible?

Four key components: error correction code, error decoding, qubit definition, and qubit control with icons for each

These four components make up the fault-tolerant quantum computer architecture

Error correction code: how to connect qubits to enable error detection, with surface code and color code diagrams

Error decoding: how to identify and fix errors while preserving quantum information, with decoder diagrams

Qubit definition: the choice of hardware like superconducting circuits or photonic systems, with qubit icons

Qubit control: techniques to manipulate qubits such as different pulse shapes and amplitudes, with waveform icons

Different hardware requires different error correction: superconducting, trapped ion, and photonic approaches compared

How you control qubits determines what errors you get: error types for superconducting, trapped ion, and photonic systems

System speed constraints determine the decoding approach: fast vs slow systems need different decoder strategies

Plaquette helps tie it all together: simulate and refine all four components for fault-tolerant architectures

Do you really need 10000 physical qubits?

Common estimates of 1000 to 100000 physical qubits per logical qubit are rough rules of thumb that depend on the situation

Figuring this out is known as estimating the overhead

Three key factors determine overhead: architecture, application, and types of hardware imperfections

Four elements of an architecture: error correction code, error decoding, qubit definition, and qubit control

Threshold plot showing logical error rate vs hardware imperfection, with fault tolerance threshold marked

Threshold plot with curves for code sizes 3, 5, and 7, linked to qubit grid diagrams of increasing size

Table of gate counts by application: scientific breakthrough (10M+), fertilizer (1B+), drug discovery (1B+), batteries (10T+)

Gate count sets required logical error rate on the threshold plot y-axis, shown with example for 10 million gates

More gates require lower error rates, which means larger logical qubits with more physical qubits per logical qubit

Bar chart of fault tolerance thresholds for different error types: bit flip, dephasing, leakage, and erasure

Trade off: build larger logical qubits or pick a better architecture to reduce overhead

But how do you know which architecture to choose?

Simulation is the only way to estimate physical qubit overhead across architectures and imperfections

Plaquette simplifies threshold calculations, comparing two architectures with their imperfection threshold profiles

Do you have a favourite? Do you wish we covered anything else? Send us a message on LinkedIn or contact us here.