⚛️ quantum physics

Plaquette: A hardware-aware design platform for fault-tolerant quantum computers

This paper introduces Plaquette, a hardware-aware design platform that computes the logical performance of fault-tolerant quantum computers by directly translating diverse physical error models—such as leakage, scattering, and heating—into accurate simulation results, thereby overcoming the limitations of traditional stochastic Pauli approximations for reliable error budgeting and threshold estimation.

Original authors: Raul Conchello Vendrell, Carlos Díaz López, Ish Dhand, Kshitij Kapoor, Davide Laureti, Marcello Massaro, Pranjal Nayak, Ivan Ogloblin, Martin B. Plenio, Shreya Prasanna Kumar, Matteo Santandrea, Varun

Published 2026-07-10

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Raul Conchello Vendrell, Carlos Díaz López, Ish Dhand, Kshitij Kapoor, Davide Laureti, Marcello Massaro, Pranjal Nayak, Ivan Ogloblin, Martin B. Plenio, Shreya Prasanna Kumar, Matteo Santandrea, Varun Seshadri, Antal Száva, Trevor Vincent, Raphael Weber

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are building a super-advanced robot that thinks in quantum mechanics. You want it to be perfect, but the real world is messy. The robot's brain (the hardware) gets tired, leaks energy, and sometimes gets confused by the temperature of the room.

For a long time, engineers trying to build these robots had to use a very simplified map to plan their journey. They assumed the robot's brain only made simple, random mistakes, like flipping a coin. They called this "Pauli noise." It was like saying, "Okay, the robot might trip over a rock, but it will never get stuck in a tree or fall into a puddle."

But in reality, quantum robots are more complicated.

Superconducting robots (like transmons) sometimes jump out of their normal "bedroom" (computational space) into a "third floor" they aren't supposed to visit.
Neutral atom robots (like Rydberg atoms) sometimes get stuck in a hallway (intermediate state) while trying to move between rooms.
Trapped ion robots (like ions in a cage) get hotter and hotter as they vibrate, changing how they behave over time.

The old maps didn't show these extra floors, hallways, or temperature changes. They just said, "Oops, random error." This made the engineers think their robots were much better than they actually were.

Enter Plaquette: The Realistic GPS

A team from QC Design GmbH has built a new tool called Plaquette. Think of Plaquette as a high-tech GPS that doesn't just look at a flat map; it looks at the actual physics of the robot's brain.

Instead of pretending the robot only makes simple coin-flip mistakes, Plaquette lets engineers describe the robot's real physics once—using the actual laws of motion and energy (like Hamiltonians and Lindblad equations). Then, Plaquette automatically translates this complex physics into different "languages" that different simulation tools can understand.

It's like having a master chef who takes one complex recipe (the real physics) and instantly converts it into a simple list of ingredients for a beginner cook, a detailed diagram for a pro, or a 3D model for a robot, all without changing the original recipe.

The New Tools: XPauli and Near-Clifford

The paper introduces two special "lenses" inside Plaquette that let us see things the old maps missed:

The XPauli Lens (The "Leakage Tracker"):
Imagine your robot has a secret third floor. If it jumps there, the old maps just said, "It's gone!" and stopped tracking it. The XPauli lens says, "Wait, it's on the third floor! Let's keep track of it as a 'leaked' state." It treats the robot's main brain as a stable, easy-to-calculate system, but adds a simple tag to say, "Oh, and this part is currently stuck in the attic." This allows the simulation to run fast (like the old maps) but still catch those tricky jumps.
The Near-Clifford Lens (The "Coherence Catcher"):
Sometimes the robot doesn't just make a random mistake; it makes a smooth, coordinated mistake, like a dancer spinning the wrong way. The old maps couldn't see this dance; they just saw a stumble. The Near-Clifford lens breaks this smooth dance down into a series of simple steps, calculating the result by averaging many different possibilities. It's a bit more expensive to compute, but it catches the subtle, coordinated errors that the simple maps miss.

What the Simulations Showed

The authors didn't just build the tool; they tested it with three different types of quantum robots to see if the old maps were lying to them.

1. The Superconducting Robot (The Leaky Transmon):
They simulated a robot where the "third floor" (leakage) was a big problem.

The Result: When they used the old "Pauli-only" map, the robot looked like it could handle a noise level of 0.0177. But when they used the new XPauli lens, the robot could only handle 0.0148.
The Takeaway: The old map was too optimistic. It made the robot look about 20% better than it really was. If you built a robot based on the old map, it might fail sooner than you thought.

2. The Neutral Atom Robot (The Scattering Hallway):
They looked at a robot that gets stuck in an intermediate hallway.

The Result: The old map said the robot could handle a certain amount of "scattering" (getting stuck). The new XPauli map said, "No way, that's too much!" The difference was huge: the old map thought the robot could handle 2.6 times more scattering than it actually could.
The Takeaway: If you ignore the hallway, you think your robot is super tough. In reality, it's fragile.

3. The Trapped Ion Robot (The Heating Up):
They simulated a robot that gets hotter as it works, which changes its error rates over time.

The Result: The old maps assumed the robot had a constant, average temperature. The new simulation tracked the heat rising round by round. The results showed that the robot's performance dropped much faster than the simple average predicted. The new simulation found a threshold of 0.01087, proving that the "heating" effect is a real, measurable problem that simple models miss.

The Big Picture

The paper argues that if you want to build a fault-tolerant quantum computer (one that can fix its own mistakes), you can't rely on the simplified "Pauli noise" maps anymore. They are like using a 2D map to navigate a 3D city; you'll miss the stairs, the elevators, and the traffic jams.

Plaquette is the tool that lets engineers see the 3D city. It takes the real physics of the hardware, simulates it with different levels of detail (from fast approximations to exact calculations), and tells you the real limits of your machine.

The authors show that by using these more accurate simulations, we can stop overestimating how good our hardware is. This helps engineers focus their efforts on fixing the real problems—like leakage, scattering, and heating—rather than chasing ghosts that only exist in simplified maps.

In short: The old way was a guess. Plaquette is a measurement. And the measurement says, "Your robot is cooler than you thought, but it's also more fragile than you thought. Let's fix the real leaks."

Technical Summary: Plaquette: A Hardware-Aware Design Platform for Fault-Tolerant Quantum Computers

Problem Statement

The design of fault-tolerant quantum computers (FTQCs) faces a critical gap between abstract theoretical thresholds and the physical realities of hardware. While the threshold theorem guarantees that logical errors can be suppressed if physical noise is sufficiently low, it relies on abstract fault rates and assumptions (e.g., rapidly decaying correlated errors) that do not directly map to measurable device parameters such as coherence times, leakage rates, heating rates, or control miscalibrations.

Current scalable simulation methods for FTQC design predominantly rely on stabilizer simulators (e.g., Stim) which assume stochastic Pauli noise. However, real hardware imperfections often deviate significantly from this model:

Superconducting transmons leak into higher energy levels (e.g., $|2\rangle$ ).
Neutral atoms scatter through intermediate electronic states.
Trapped ions experience heating as motional modes absorb phonons.
Control fields may cause coherent over-rotations.

These processes involve non-Pauli structures, leakage, and environmental interactions that stochastic Pauli approximations (often derived via Pauli twirling) fail to capture accurately. Consequently, existing design tools may provide overly optimistic estimates of logical error rates and thresholds, leading to flawed resource budgets and engineering decisions.

Methodology: The Plaquette Framework

The authors present Plaquette, a software suite and theoretical framework designed to compute the logical performance of FTQC architectures directly from the open-system physics of a device. The core philosophy is a "channel-first" approach: the physical error model is specified once as a Completely Positive Trace-Preserving (CPTP) map, and the framework automatically compiles this into the specific representation required by different simulation samplers.

1. Input and Formalism

Device Model: Defined by physical parameters $\eta$ (e.g., Hamiltonians, Lindblad operators, control durations). These define a CPTP channel $\mathcal{E}_\eta$ for every circuit location.
Compilation: Plaquette converts the physical channel into the representation needed by the chosen sampler and a separate Detector Error Model (DEM) for the decoder.
Workflow: A noiseless syndrome-extraction circuit is generated from a QEC code. The compiled error channels are inserted to create a noisy circuit. This circuit is sampled, syndromes are decoded, and logical error rates are aggregated to determine thresholds and overheads.

2. Sampler Hierarchy

Plaquette employs a hierarchy of samplers that trade off accuracy for scalability, all operating on the same underlying physical channel:

Stim (Stabilizer): Handles stochastic Pauli and erasure noise. It uses the standard Pauli-twirled approximation, discarding off-diagonal coherence and leakage.
XPauli Sampler: A novel extension for systems with leakage and environment sectors. It tracks qubits in the computational subspace as a stabilizer state while representing leaked levels and environmental states (sectors) via classical labels. It assumes incoherence between these non-computational states, allowing for efficient classical-jump simulation while retaining leakage dynamics.
Near-Clifford Samplers: Designed for coherent errors and non-unital channels. These decompose non-Clifford operations into weighted sums of Clifford operations (quasiprobability decomposition).
- Channel-level: Decomposes the channel $\mathcal{E} = \sum \alpha_k \Phi_k$ .
- Operator-level: Decomposes unitaries $U = \sum c_i C_i$ .
- These methods introduce a variance cost proportional to the "robustness" of the decomposition but avoid full-state simulation costs.
Full-State Samplers: Propagate the exact state vector or density matrix (CPU via Cirq, GPU via cuQuantum). These serve as exact references for validating the approximate samplers but scale exponentially with system size.

3. Decoding and Analysis

Decoders: Plaquette decouples sampling from decoding. Decoders (e.g., PyMatching, Fusion-Blossom) are initialized from a DEM derived from a Pauli-twirled version of the circuit. The framework supports "loss-aware decoding" for delayed heralding events.
Thresholds: The framework calculates logical error rates across scaled code families to estimate thresholds and threshold surfaces (multi-dimensional parameter spaces). It uses finite-size scaling (FSS) and interpolation to determine the boundary between correctable and uncorrectable regimes.

Key Contributions

A Channel-First Design Framework: Plaquette enables the specification of physical error models as CPTP channels (derived from Hamiltonians, Lindblad dynamics, or experimental reconstruction) and automatically compiles them into various sampler representations without manual reformulation.
The XPauli Sampler: A new, efficient simulator for leakage and environment sectors. It extends stabilizer simulation to track non-computational levels and sectors classically, bridging the gap between fast Pauli simulators and intractable full-state simulations.
Evidence of Approximation Limits: The paper demonstrates that Clifford-only (Pauli-twirled) simulations can yield significantly different (and often overly optimistic) logical error rates and thresholds compared to more accurate methods (XPauli, Near-Clifford, Full-State) when dealing with realistic hardware noise.

Results and Validation

The authors validate the framework using three distinct hardware platforms and error models:

1. Simplified Error Models (Validation)

Coherent Over-rotation: A unitary rotation error was simulated. The Near-Clifford sampler matched full-state results, while the Pauli-twirled Stim simulation significantly underestimated the logical error rate (discarding coherence).
Leakage: A leakage channel ( $|11\rangle \leftrightarrow |02\rangle$ ) was simulated. The XPauli sampler matched full-state results, whereas Stim (which traces out leakage) failed to capture the error dynamics, again underestimating the logical error rate.

2. Superconducting Qubits (Leakage)

Model: A transmon CZ gate derived from a Hamiltonian with heating Lindblad operators.
Finding: The leakage-aware XPauli threshold ( $\gamma_{th} \approx 0.0148$ ) was approximately 20% lower than the threshold estimated by the Clifford-only Pauli-twirled approximation ( $\gamma_{th} \approx 0.0177$ ). At large code distances ( $d=19$ ), the logical error rate difference reached an order of magnitude. This indicates that ignoring leakage leads to overestimating the hardware's fault-tolerance margin.

3. Neutral Atoms (Intermediate-State Scattering)

Model: Rydberg gates with spontaneous emission from intermediate states.
Finding: The authors mapped threshold surfaces across depolarization, dephasing, and scattering rates. The Clifford-only approximation overestimated the tolerable scattering rate by a factor of 2.6 compared to the XPauli calculation. The volume between the two surfaces represents a region classified as "correctable" by the simplified model but "uncorrectable" by the leakage-aware model.

4. Trapped Ions (Heating)

Model: Heating of motional modes modeled as a sector transition process, where error rates depend on the current phonon number (sector).
Finding: The framework successfully simulated non-stationary noise where error probabilities evolve over time based on the heating history. The results showed that a stationary Pauli approximation (using an average error rate) fails to capture the dynamics of the non-stationary heating process, highlighting the necessity of sector-resolved modeling.

Significance and Claims

The paper claims that Plaquette provides a direct path from the open-system physics of a device to the logical performance of an FTQC.

Design Impact: By accurately modeling hardware imperfections as quantum channels, Plaquette allows hardware teams to answer practical engineering questions: Is the noise below threshold? By how much? Which specific imperfection limits performance?
Reliability: The authors argue that reliable thresholds, error budgets, and overhead estimates require the most accurate simulation available. Relying on Clifford-only approximations for non-Pauli noise can lead to designs that fail to reach fault tolerance in practice.
Scope: The framework is hardware-agnostic, supporting superconducting circuits, neutral atoms, trapped ions, quantum dots, and photonics, across circuit-based, measurement-based, and fusion-based paradigms.

The paper concludes that while the XPauli and Near-Clifford samplers introduce specific approximations (incoherence between sectors or variance costs), they offer a necessary and accurate middle ground between the untrustworthy simplicity of Pauli twirling and the intractable cost of full-state simulation for large-scale FTQC design.