Store one bit across a 3D lattice of qubits and let every qubit fix itself by asking only its four neighbouring checks. In 3D the errors form closed loops that shrink away. In 2D they form points that wander off and erase the bit. Try both below, then see what that predicts for a real 384-atom machine.
Tap or click the lattice to drop errors at that spot, and drag sideways to turn it. Same rule in both: flip a qubit when most of its checks report an error. Checks are read once per round and can be wrong. The bit is tested every 10 rounds by a full readout and decode. Both lattices hold a similar number of qubits (648 in 3D, 512 in 2D).
This is the digital twin from Result 3, running live in this page. Every check is measured with real gates on a fixed schedule, with gate errors, readout errors and atom loss. Pick the hardware, press run, then try the larger lattice. Below the threshold, the larger lattice should fail less often.
| Run | Lattice | Gate | Readout | Loss | Lost | Error / round |
|---|---|---|---|---|---|---|
| Your runs will appear here so you can compare them. | ||||||
Lost atoms are replaced by fresh atoms in a random state, and the decoder is not told which ones were lost. Lab time assumes about 1 ms per round. Atom moves between zones are not modelled. Nothing here has run on a quantum computer: no group has yet built a 3D membrane memory.
A thermal Monte Carlo of the lattice: every check costs energy when it reports an error, and the lattice is held at a temperature. Choose 2D strings or 3D membranes, a temperature and a size, then run. The simulator times how many sweeps each run lasts before the stored bit is lost. 3D below its transition near T = 1.31 should outlast 2D by a wide margin, and grow with size.
Each run is capped at 4,000 sweeps. The bit is checked every 25 sweeps by decoding a copy of the lattice. 3D transition: T ≈ 1.31.
| Run | Lattice | T | Median life | Survived |
|---|---|---|---|---|
| Runs appear here. Try 3D at 4 and then 6 at the same temperature. | ||||
A 4×4×4 lattice of 192 qubits. Tap near an edge to flip that qubit. The checks around it light up. Each decoder step lets every qubit read its four checks and flip itself if most of them report an error. That is the entire decoder: four bits read and one vote per qubit, so a step costs the same at any size. Then try the one error no local check can see.
The hidden membrane flips a whole plane of qubits. Every check sees two flips and stays dark, yet the stored bit is now wrong. A local decoder cannot see it, which is why the code makes such membranes cost a whole plane: noise almost never builds one.
Set the lattice and the machine's figures. The builder counts atoms, times each round, checks your settings against the tolerances measured in the stress tests, and animates the gate schedule every check uses. Timings are your assumptions; the tolerances come from the simulations on this page.
| Requirement | Your setting | Verdict |
|---|
Layer 1 of 4.
Thermal Monte Carlo of the lattice gauge model, 60 to 100 runs per point. Lifetime is the number of sweeps until the bit is lost half the time. The 3D bit's lifetime fits τ ≈ τ₀·ebL with b = 0.51 at T = 1.30 (R² = 0.993) and b = 0.73 at T = 1.28 (R² = 0.999). The 2D bit loses lifetime as it grows, even at a much lower temperature.
Every check is measured with real gates: ancilla preparation, four CNOTs on a collision-free schedule, then a readout. Noise follows every gate, preparation, measurement and idle period. Correction uses the same one-round local rule. Below the threshold, failure falls as the lattice grows; above it, failure rises.
CZ fidelity of 99.5% on up to 60 atoms in parallel (Harvard, 2023) and 99.854% (Harvard, 2026). At 0.5% gate error, an 8×8×8 memory had zero failures in 1,000 rounds across 200 runs.
The proposed first experiment, simulated with each operation at a published error rate: 99.854% CZ gates, 0.1% atom loss per gate and per image, and an assumed 1% readout error (scanned from 0.5% to 3%). Every lost atom is replaced by a fresh one in a random state, and the decoder is not told which atoms were lost. Both choices are deliberately pessimistic.
| Lattice | Atoms | Failures after 10,000 rounds | Logical error per round | Fits on |
|---|---|---|---|---|
| 4×4×4 | 384 | 3 of 300 | ≈ 1×10⁻⁶ (3 events: about 0.2–3×10⁻⁶) | today's 448-atom processor |
| 6×6×6 | 1,296 | 0 of 300 | < 5×10⁻⁷ | 3,000-atom arrays |
| 8×8×8 | 3,072 | 0 of 200 (1,000 rounds) | not resolved | 3,000+ atom continuous arrays |
Each data qubit picks up about a 0.6% chance of a bit flip per round, so the memory suppresses errors by thousands of times. At 2–3% readout error, the 6×6×6 lattice still beats 4×4×4 after 1,000 rounds (0–0.3% failure against 1.0%). That larger-is-better signature is what a real experiment would look for.
| Lattice | Data qubits | Check helpers | Total | Status |
|---|---|---|---|---|
| L = 4 | 192 | 192 | 384 | fits current hardware |
| L = 6 | 648 | 648 | 1,296 | fits 3,000-atom arrays |
| L = 8 | 1,536 | 1,536 | 3,072 | just fits |
| L = 10 | 3,000 | 3,000 | 6,000 | 6,100-atom arrays |
| L = 12 | 5,184 | 5,184 | 10,368 | beyond operational arrays |
Each bar is the share of 200 simulated runs that lost the bit over 1,000 rounds (the quantum sector uses 80 to 150 runs over L rounds). While the larger lattice fails less, the memory is below threshold and scaling up helps. When the bars meet, the hardware has crossed the line.
Two comparisons to keep in view. A 2D surface code protects a full quantum bit at a similar threshold on a flat chip. A repetition code stores one classical bit with fewer qubits and more noise tolerance, but needs a global decoder across many rounds. The membrane memory's edge is local, constant-time correction and passive thermal stability.