Distance-scaling fault tolerance of the three-sheet multiplexed FCC sheet code at L = 4, 6, 8

Distance-scaling fault tolerance of the three-sheet multiplexed FCC

sheet code at L = 4, 6, 8

Raghu Kulkarni

SSMTheory Group, IDrive Inc., Calabasas, CA 91302, USA , raghu@idrive.com

Abstract

We provide a circuit-level numerical validation of the three-sheet time-multiplexed FCC

sheet code [

], a quantum low-density parity-check (qLDPC) construction with parameters

[[3

L, L

]] derived from the three triad sheets of the face-centered cubic lattice. At

= 4

the code packs 24 logical qubits into 192 data qubits at distance 4, an encoding rate of 12.5%,

higher than any other published code at this distance. Three independent sheet-codes share

one chip; ancillas are shared, stabilizers are extracted in three sequential rounds, and the

inactive sheets accumulate depolarizing noise during each round at rate 2

. We simulate

the full circuit-level memory experiment with explicit CNOT cascades, depolarizing noise on

every gate, and minimum-weight perfect matching decoding via PyMatching [

] on Stim’s [

]

detector error model. Threshold under the multiplex idle penalty falls between 0.4% and

0.5%, in agreement with [

]. Distance scaling is sharp: the per-logical error rate suppresses

by Λ(4

→

6) = 11

2 between consecutive even

= 0

001, and Λ(6

→

8) = 7

8. At

= 8

the [[1536

8]] code achieves a per-logical error rate of 5

−5

, more than an order of

magnitude below the physical rate, on a 48-logical-qubit memory. These suppression factors,

measured in simulation deeply sub-threshold, are over ﬁve times those recently reported on

noisy hardware [

] on a single-logical surface-code memory; an apples-to-apples comparison

at matched operating point requires either future hardware experiments on this code or a

surface-code simulation at the same deeply sub-threshold operating point and is not made

here. The natural hardware target is the

= 6 instance: [[648

6]] encodes 36 logical qubits

at distance 6 in 864 physical qubits, ﬁtting Atom Computing’s 1180-qubit Phoenix processor

and exceeding every prior multi-logical hardware demonstration in distance and logical-qubit

count. The

= 4 instance overlaps with Atom Computing and Microsoft’s 24-logical [[4

2]]

demonstration [

], providing a calibration point at quadrupled distance (

= 4 vs

= 2) and

full error correction in place of error detection.

Keywords: quantum error correction, qLDPC codes, FCC sheet code, time-multiplexed

measurement, fault-tolerant scaling, neutral-atom quantum computing

1 Introduction

Surface codes [

] dominate the quantum-error-correction landscape because they pair a high

circuit-level threshold (

∼

1%) with a planar layout requiring only nearest-neighbor connectivity.

Their cost is rate: a distance-

rotated surface code encodes one logical qubit in

∼

physical

qubits, and the qubit overhead per logical scales as

. Recent qLDPC constructions, notably

IBM’s bivariate-bicycle (BB) family [

], demonstrate that this overhead can be reduced; the

[[144

12]] BB code packs 12 logicals at distance 12 into 144 qubits, at the cost of weight-6

stabilizers and a non-planar layout. Google’s Willow processor [

] recently demonstrated below-

threshold fault tolerance on the surface code with Λ

≈

14 across distances 5 through 7, but the

experiment encoded only one logical qubit.

Reference [

] introduces the FCC sheet code, an alternative qLDPC construction obtained by

restricting a face-centered cubic stabilizer code [

] to a single triad sheet. The single-sheet code

has parameters [[

L, L

]] with weight-4 stabilizers and per-qubit connectivity

= 4, the same

as the surface code. At

= 4 the single sheet is [[64

4]]: 8 logicals at distance 4 in 64 qubits, an

encoding rate of 12.5%. Three independent sheets exist on the same FCC lattice, edge-disjoint but

sharing vertex and octahedral-void ancilla positions. Time-multiplexing across the three sheets

gives a combined [[3

L, L

]] code on a single chip: 24 logicals at distance 4 in 192 data qubits

at L = 4, with the same 12.5% rate.

This paper provides circuit-level validation of the three-sheet multiplexed conﬁguration at

= 4

8. We conﬁrm the parameters of the sheet code at all three lattice sizes, verify the

threshold under both single-sheet and multiplex operation matches the values reported in [

], and

measure the suppression factor Λ between consecutive even

. The headline result is that the

three-sheet code shows fault-tolerant scaling on a multi-logical memory, with Λ values dramatically

larger than what current hardware demonstrations report, on a code that ﬁts today’s largest

neutral-atom processors.

The rest of the paper is organized as follows. Section 2 recapitulates the sheet-code construction

and the three-sheet time-multiplexing protocol, ﬁxing notation. Section 3 describes the simulation

methods. Section 4 veriﬁes the construction’s algebraic parameters at

= 4

8. Section 5

measures the threshold under the multiplex idle model. Section 6 is the central numerical result:

per-logical error-rate scaling and Λ values. Section 7 places the code in the rate–distance landscape.

Section 8 reports hardware feasibility. Section 9 discusses limitations. We do not address the

high-rate base FCC code or its ﬂag-assisted variant, both of which require weight-12 stabilizers

and K = 12 connectivity outside the scope of current hardware.

2 The Three-Sheet Multiplexed FCC Code

2.1 The triad decomposition

The face-centered cubic (FCC) lattice has

= 12 nearest-neighbor vectors, partitioning into three

orthogonal triad sheets [1]:

: (±1, ±1, 0) S

: (±1, 0, ±1) S

: (0, ±1, ±1)

At even lattice size

, each sheet contains exactly

edges. Every edge of the FCC lattice belongs

to exactly one sheet. Each sheet is therefore an edge-disjoint

= 4 sub-lattice on the same set of

FCC vertices and octahedral voids. Figure 1 shows the construction in three views.

2.2 The single-sheet code

Fix one triad sheet

. Place a physical qubit on each of the

edges in

. Stabilizers come in

two types, both weight 4 [2]:

• Z-stabilizers: for each FCC vertex v, the Z-parity over the 4 sheet-S edges incident to v.

•

X-stabilizers: for each octahedral void

, the X-parity over the 4 sheet-

edges of the

surrounding octahedron.

The resulting code has parameters [[

L, L

]] at even

physical qubits,

= 2

logical qubits,

code distance [

]. Each layer of ﬁxed sheet-orthogonal coordinate forms an

independent 2D toric code on a rotated square lattice; the sheet is therefore

parallel toric layers

stacked along the orthogonal axis.

(a) FCC lattice: K = 12 cuboctahedral neighborhood (b) Three triad sheets, 4 edges each

: (±1, ± 1, 0)

: (±1, 0, ± 1)

: (0, ± 1, ± 1)

): weight-4 stabilizers

Z-ancilla (FCC vertex)

X-ancilla (oct. void)

Data qubit (sheet edge)

Figure 1: The FCC sheet-code construction. (a) The 12 nearest neighbors of any FCC vertex sit at

the vertices of a cuboctahedron (faint blue surface). (b) These 12 bonds partition into three orthogonal

sheets of four bonds each:

(red),

(green),

y z

(blue). (c) Within one sheet, qubits sit on edges

(yellow squares); Z-stabilizers are the weight-4 vertex parity checks (red ancilla, four incident sheet edges);

X-stabilizers are the weight-4 octahedral-void parity checks (blue ancilla, four sheet edges around the

octahedron). The three-sheet code interleaves three such structures on a single FCC chip with shared

vertex and oct-void ancillas.

2.3 Three-sheet time multiplexing

All three sheets coexist on a single FCC chip: 3

data qubits partitioned into three edge-disjoint

groups of

, plus

2 vertex Z-ancillas and

2 octahedral X-ancillas, with each ancilla

physically shared across all three sheets. The total physical-qubit count is therefore 4

: 256 at

L = 4, 864 at L = 6, and 2048 at L = 8.

Stabilizers are extracted in a three-round cycle: round 1 measures sheet

’s stabilizers, round

2 measures

’s, round 3 measures

’s. From the perspective of any one sheet, two of every

three measurement rounds are idle. If a single round takes time

, each sheet’s data qubits sit

idle for 2

between consecutive active measurements. This translates to per-round depolarizing

noise at eﬀective rate 2

on every data qubit, independent of and additional to the gate-level noise

that occurs during stabilizer extraction [

]. In Stim [

], the multiplex penalty is implemented by

inserting DEPOLARIZE1(2p) on all data qubits before each round of stabilizer extraction.

The encoded subspace is the direct sum of the three sheets’ code spaces. The combined

parameters are [[3

L, L

]] at periodic boundaries, with rate 2

. Per-logical performance

under the multiplex penalty is identical for each of the three sheets by symmetry. Writing

for

the single-sheet block error rate, the three-sheet block error rate is 1

−

− p

)

: the sheets fail

independently, so for memory experiments alone the three-sheet code is operationally equivalent

to running three [[

L, L

]] blocks side by side. We quote the combined [[3

L, L

]] parameters

because they reﬂect the chip-level resource: a single 4

-qubit FCC processor running one shared

multiplex protocol, with shared ancillas, shared decoder pipeline, and shared classical control. This

framing also previews the natural follow-up: transversal and lattice-surgery operations between

sheets, which will couple the codes non-trivially and require treating the joint Hilbert space as a

single object (Section 9).

3 Methods

All circuits are built and sampled in Stim 1.15 [

]. We construct the FCC lattice for each

identify xy-sheet edges, build vertex-incident weight-4 Z-stabilizers and octahedral-void weight-4

X-stabilizers, and compute the parity-check matrices

(2). CSS validity (

⊤

mod

2) is checked explicitly. Logical-Z observables are obtained by reducing each kernel-of-

L 1-sheet code 3-sheet code Phys. qubits Rate (3-sheet) CSS

4 [[64, 8, 4]] [[192, 24, 4]] 256 12.5% yes

6 [[216, 12, 6]] [[648, 36, 6]] 864 5.6% yes

8 [[512, 16, 8]] [[1536, 48, 8]] 2048 3.1% yes

Table 1: Sheet code parameters at

= 4

8. The physical-qubit column counts data plus shared ancillas

): 3

data qubits across three sheets, plus

2 vertex Z-ancillas and

2 octahedral X-ancillas

shared by all three sheets. Encoding rate of the 3-sheet code is 6

= 2

. All constructions veriﬁed

CSS valid by direct GF(2) computation.

basis element modulo the row span of H

The memory experiment circuit consists of

rounds of stabilizer extraction followed by a ﬁnal

destructive measurement of all data qubits in the

basis. Each round of stabilizer extraction

comprises:

1. the multiplex idle penalty: DEPOLARIZE1(2p) on all data qubits;

Z-stabilizer extraction via CNOT cascade (data

→

ancilla), with

DEPOLARIZE2(p)

after each

CNOT and X_ERROR(p) on ancilla resets and measurements;

X-stabilizer extraction via Hadamard-CNOT-Hadamard (ancilla

→

data), with the same

noise placement.

Detector annotations are placed on the Z-stabilizer outcomes only (this is a Z-memory ex-

periment, so X-stabilizer outcomes are non-deterministic on the

⟩

initial state). First-round

Z-stabilizer detectors are anchored to the deterministic +1 outcome expected on

⟩

; subsequent

rounds compare consecutive measurements; ﬁnal destructive data measurements close out each

Z-stabilizer’s history.

Decoding is performed by minimum-weight perfect matching using PyMatching 2.3 [

] on

Stim’s detector error model ([

], decompose-errors mode). For each shot, Stim’s compiled detector

sampler produces the detection-event pattern and the actual observable ﬂips; PyMatching predicts

the observable ﬂips from the detection events; a logical error on observable

is recorded when

prediction and actual disagree on observable

. Block error rate is the fraction of shots with at

least one disagreement; per-logical error rate is the average disagreement rate per observable.

Sample sizes are 30 000 shots per (

p, L

) point at

= 4

6 and 20 000 shots at

= 8. The

complete simulation pipeline — FCC lattice construction, parity-check matrix veriﬁcation, Stim

circuit assembly, sampling, decoding, and aggregation — is contained in three Python scripts

linked individually in the Code and Data Availability section.

4 Static Veriﬁcation of the Construction

Building the sheet code from the FCC lattice at

= 4

8 yields the parameters predicted in [

Stabilizer ranks satisfy

rank

(

) =

rank

(

) = (

−

)

2, giving

−

(

−

) = 2

per sheet. The three-sheet count k

= 6L follows from edge-disjointness. Table 1 summarizes.

5 Threshold Under the Multiplex Idle Model

We ﬁrst establish the threshold with and without the three-sheet multiplex penalty, to verify that

our circuit-level model agrees with [

]’s analytical claims (Section 9.3 of that work). For threshold

determination only, we use Stim’s built-in

surface_code:rotated_memory_z

circuit at distances

−1

Physical error rate (%)

−4

−3

−2

−1

Sheet code logical error rate

paper:

0.63%

(a) Single-sheet operation (no idle noise)

L = 3

L = 5

L = 7

L = 9

L = 11

−1

Physical error rate (%)

paper:

0.42%

(b) 3-sheet multiplexing (idle noise = 2p)

L = 3

L = 5

L = 7

L = 9

L = 11

Sheet code threshold: single-sheet vs three-sheet multiplexing

Figure 2: Sheet code threshold with and without the multiplex idle penalty, MWPM decoding via

PyMatching. Each panel shows sheet-code logical error rate (union over

layers) vs physical depolarizing

rate at

= 3

11. (a) Single-sheet operation: curves cross near 0.65–0.7%, consistent with [

]’s

analytical threshold of 0.63%. (b) Three-sheet multiplexing with idle decoherence

DEPOLARIZE1(2p)

per

round: curves cross near 0.42–0.45%, in close agreement with [2]’s analytical threshold of 0.42%.

= 3

11, which is mathematically identical to one layer of the sheet code (per Section 4

of [2], each sheet decomposes into L independent rotated 2D toric layers). The full custom FCC

sheet-code circuit constructed in Section 3 is used for the distance-scaling result in Section 6.

The protocol is identical except for the

before_round_data_depolarization

parameter: 0 for

single-sheet operation, 2p for three-sheet multiplexing.

Figure 2 shows sheet-code logical error rates (computed as 1

−

− p

per-layer

)

, the union over

independent layers) against physical depolarizing rate, for

= 3

11. Curves at diﬀerent

cross at the threshold. Single-sheet operation (left) gives a threshold near 0.65–0.7%, slightly

above [

]’s claimed 0.63%. Three-sheet multiplexing (right) gives a threshold near 0.42–0.45%, in

close agreement with [

]’s claimed 0.42%. The 1.5

reduction in threshold under multiplexing

matches the analytical prediction.

6 Sub-Threshold Distance Scaling

The central numerical result of this paper is the sub-threshold per-logical error rate scaling with

for the three-sheet multiplexed code. We run the full circuit-level memory experiment at

= 4

with the multiplex idle penalty applied, sweeping

from 10

−4

to 5

−3

. Table 2 reports the

per-logical error rate at each (

L, p

); Table 3 reports the corresponding suppression factors Λ.

Figure 3 shows both as a single combined plot.

= 0

001 (current trapped-ion two-qubit-gate-ﬁdelity regime), the per-logical error rate is

−3

= 4, 4

−4

= 6, and 5

−5

= 8. The corresponding suppression

factors Λ(4

→

6) = 11

2 and Λ(6

→

8) = 7

8 mean the per-logical error rate drops by roughly an

order of magnitude per increase of two in

. The full three-sheet block error rate 1

−

− p

)

approximately 1.6% at L = 6 and 0.3% at L = 8.

The threshold conﬁrmed in Section 5 manifests in the Λ behavior of Table 3: as

approaches

0.5%, Λ falls toward 1, and at

= 0

005 (just above threshold) the suppression has essentially

disappeared. The crossover is sharp, as expected for a code with a well-deﬁned threshold.

p L = 4 L = 6 L = 8

0.0001 3.4 × 10

−4

2.8 × 10

−6

0 / 20 000

0.0003 1.1 × 10

−3

2.8 × 10

−5

6.3 × 10

−6

0.0005 2.3 × 10

−3

1.3 × 10

−4

1.6 × 10

−5

0.001 5.2 × 10

−3

4.6 × 10

−4

5.9 × 10

−5

0.002 1.3 × 10

−2

2.8 × 10

−3

7.2 × 10

−4

0.003 2.5 × 10

−2

7.6 × 10

−3

2.8 × 10

−3

0.005 5.6 × 10

−2

3.0 × 10

−2

1.9 × 10

−2

Table 2: Per-logical error rate at (

L, p

) for the three-sheet multiplexed code under

DEPOLARIZE1(2p)

idle

penalty. 30 000 shots at

= 4

6 and 20 000 shots at

= 8. “0 / 20 000” indicates no errors observed in the

sample.

p Λ(4 → 6) Λ(6 → 8)

0.0003 39.0 —

0.0005 17.1 —

0.001 11.2 7.8

0.002 4.6 3.9

0.003 3.2 2.7

0.005 1.9 1.6

Table 3: Distance-suppression factor Λ(

L → L

+ 2) =

per-log

(

)

per-log

(

+ 2). Em-dashes indicate the

higher-

rate fell below the shot ﬂoor. The bold row at

= 0

001 corresponds to currently demonstrated

trapped-ion two-qubit gate ﬁdelities. For comparison, Google’s Willow processor [

] reports Λ

≈

14 on a

single-logical surface code memory.

7 Rate–Distance Landscape at d = 4

At distance 4, the three-sheet multiplexed FCC code occupies a distinguished point in the

rate–distance landscape. Table 4 compares it directly to other published codes at d = 4.

Per-logical, the rotated surface code at

= 4 is more reliable: a single [[16

4]] code block has

a per-logical error rate near 5

−4

= 0

001, compared to the three-sheet code’s 5

−3

The factor of

∼

per-logical advantage to the surface code is partly oﬀset by its 2

data-qubit

cost per logical qubit (16 vs 8). The surface code wins on per-logical ﬁdelity at

= 4, but the FCC

three-sheet code is more compact in physical-qubit footprint, with the 2

rate advantage holding

at all

by construction (2

for the FCC code vs 1

for the surface code). At

= 8 the FCC

code’s per-logical error rate is 5

−5

, small in absolute terms, though the surface code at

the same distance would likely be smaller still. Whether the per-logical gap to surface widens or

narrows with

is determined by the relative thresholds, and a direct circuit-level comparison at

matched L is left to future work.

8 Hardware Feasibility (May 2026)

The three-sheet code at

= 4 requires 256 physical qubits at

= 4 connectivity, with both

ﬁxed-position ions/qubits and the ability to perform CNOT gates between speciﬁc neighbor pairs.

Table 5 lists the principal current platforms.

Neutral-atom hardware ﬁts the three-sheet protocol cleanly. Time-multiplexed stabilizer

extraction requires measuring sheets sequentially while idle sheets stay coherent. Optical-tweezer

rearrangement provides reconﬁgurable connectivity, so the same ancilla qubits can be paired

with diﬀerent data sets across the three rounds without rewiring the chip. The required

= 4

connectivity is native to neutral-atom arrays.

−4

−3

Physical depolarizing error rate, p

−6

−5

−4

−3

−2

−1

Per-logical error rate

3-sheet multiplexed: per-logical scaling with L

L = 4: 3-sheet [[192,24,4]] (12.5%)

L = 6: 3-sheet [[648,36,6]] (5.6%)

L = 8: 3-sheet [[1536,48,8]] (3.1%)

−4

−3

Physical depolarizing error rate, p

Suppression factor Λ

Distance suppression (multiplex regime)

Λ(4 → 6)

Λ(6 → 8)

Willow Λ ≈ 2.14

Λ = 1 (no improvement)

FCC three-sheet multiplexed code: distance scaling under multiplex idle noise (2p)

Figure 3: Three-sheet multiplexed FCC code distance scaling. (Left) Per-logical error rate vs physical

depolarizing rate at

= 4

8. The three rate values for these codes are 12.5%, 5.6%, 3.1%. (Right)

Distance suppression factor Λ vs

. The dashed line at Λ = 2

14 marks Google Willow’s published result;

the dotted line at Λ = 1 marks the threshold. Sub-threshold Λ for the three-sheet FCC code at p = 0.001

is over ﬁve times Willow’s, on a 24- to 48-logical memory rather than one logical.

Code n k d Rate K p

at p = 10

−3

Rotated surface 16 1 4 6.3% 4 5 × 10

−4

3D toric (cubic) 192 3 4 1.6% 6 —

BB family (smallest) — — — — 6 —

MB family (smallest) — — — — — —

FCC 3-sheet (this work) 192 24 4 12.5% 4 5.2 × 10

−3

Table 4: Rate and per-logical ﬁdelity comparison at distance

= 4. The smallest instances of the BB

family are at distance 6 ([[72

6]]) and 12 ([[144

12]]), so no direct

= 4 comparison is possible.

MB-family codes also do not have published instances this small. The FCC three-sheet code has 2

the

surface code’s encoding rate and roughly 11

the surface code’s per-logical error rate at

= 10

−3

— rate

and per-logical ﬁdelity trade against each other; the FCC code wins the ﬁrst metric, the surface code

wins the second. (We follow [[

n, k, d

]] convention with

counting data qubits only, consistent with [

]’s

[[

L, L

]] notation.)

denotes per-qubit connectivity;

= 4 matches the surface code and is the

minimum supported by all current quantum hardware.

The natural near-term hardware target is

= 6: the [[648

6]] three-sheet code encodes 36

logical qubits at distance 6 in 864 physical qubits, ﬁtting Atom Computing’s 1180-qubit Phoenix

processor. To our knowledge, no hardware demonstration of fault-tolerant memory has yet reached

either 36 logical qubits or distance 6. Willow’s Λ result [

] is on a single logical qubit at distance 5

to 7. Atom Computing and Microsoft’s 2024 work [

] encoded 24 logical qubits into 48 ytterbium

atoms using the [[4

2]] code on a 256-atom processor, but the [[4

2]] code is distance 2

(error-detecting, not error-correcting). At

= 6 the FCC three-sheet code therefore exceeds both

prior results: 1.5

more logicals than Atom + Microsoft, three times the distance, and full error

correction.

The

= 4 instance ([[192

4]], 256 physical qubits) is best viewed as a calibration step. It

overlaps Atom Computing and Microsoft’s 24-logical demonstration on logical-qubit count and

atom budget, but runs at quadrupled distance with full error correction in place of detection.

Performing

= 4 ﬁrst, then

= 6 on the same processor would yield a measurement of the

suppression factor Λ on a multi-logical memory; this has not been reported on any platform.

Platform Qubits Modality L = 4 (256q) L = 6 (864q)

IBM Heron r3 156 supercond. no no

IBM Nighthawk 120 supercond. no no

Quantinuum Helios 98 trapped ion no no

Atom Computing Phoenix 1180+ neutral atom yes yes

Pasqal Orion up to 1024 neutral atom yes yes

QuEra Gemini 256 neutral atom borderline no

Table 5: Quantum hardware platforms in production as of May 2026, and their compatibility with the

three-sheet FCC code at

= 4 and

= 6. Neutral-atom platforms are the only modality with suﬃcient

qubits for the

= 4 instance; Atom Computing’s Phoenix and Pasqal’s Orion can also support

= 6 (864

physical qubits).

9 Discussion

Decoder choice. We use minimum-weight perfect matching, which is the standard choice for

surface-code-style codes and is provably near-optimal for codes with weight-4 stabilizers. We

apply MWPM to Stim’s full detector error model rather than decoding each toric layer separately,

but the layer decomposition guarantees that no correlations across layers can be exploited by a

smarter decoder — the mathematical equivalence to

independent surface codes is exact. A more

sophisticated decoder, e.g., correlated matching across rounds, or a neural-network-based decoder,

could shift the threshold modestly but is unlikely to change the qualitative scaling story.

Noise model. The depolarizing model used here is standard but does not capture leakage,

drift, slow correlated errors during transport (relevant for ions), or 1

noise (relevant for

superconducting). It does, however, capture the dominant single-qubit and two-qubit noise

mechanisms in trapped-ion and neutral-atom systems where leakage is small. The 2

idle-noise

factor used for multiplexing is a model assumption from [

]; the actual idle-noise rate on neutral-

atom platforms during atom rearrangement and shelving is a subject of separate measurement.

Distance ceiling. We tested up to

= 8. Verifying that Λ persists and continues growing

= 10

12 would require simulating circuits with 4 000 to 7 000 physical qubits and the

corresponding decoders, which is computationally feasible but exceeds our run budget here. The

local stabilizer structure does not change with

, so the threshold is expected to be invariant in

;

what could change is the decoder optimality at very large detector counts.

Logical operations. This paper concerns only the memory experiment. Logical Cliﬀord

operations on the three-sheet code, including transversal CNOTs between sheets, and lattice-

surgery protocols, are not addressed and remain a subject for follow-up work. The encoding

rate advantage measured here is most useful in regimes where many logical qubits are needed

simultaneously, which is precisely where memory and Cliﬀord operations on a multi-logical block

become important.

Comparison to Willow. Our Λ values at

= 0

001 are measured in simulation, well sub-

threshold for this code (

≈

42% under multiplex). Willow’s reported Λ

≈

14 [

] is

hardware-measured, with the surface code operating at physical error rates closer to threshold

and on a single logical qubit. A like-for-like comparison would require either running the FCC

three-sheet code on hardware at the same operating point (deferred to future work, see Section 8)

or running a surface-code memory in simulation at

= 0

001, which would also yield large Λ. The

numerical result reported here demonstrates that the FCC three-sheet code shows fault-tolerant

scaling on a multi-logical memory in the same regime where surface codes do; it does not establish

that the FCC code is intrinsically “better” than the surface code at ﬁxed operating point.

10 Conclusion

The three-sheet multiplexed FCC sheet code [[3

L, L

]] shows fault-tolerant scaling under

realistic circuit-level depolarizing noise, with Λ

≈

11 between consecutive even

= 0

001.

The

= 4 instance encodes 24 logical qubits in 192 data qubits at distance 4 with rate 12.5%, the

highest of any published code at this distance. The construction ﬁts today’s largest neutral-atom

processors, providing a concrete hardware path to a 24-logical-qubit fault-tolerant memory.

The natural near-term hardware target is the

= 6 instance: [[648

6]] encodes 36 logical

qubits at distance 6 in 864 physical qubits, ﬁtting Atom Computing’s Phoenix processor and

exceeding published multi-logical hardware demonstrations in both logical-qubit count and code

distance. The

= 4 instance is a calibration step. Beyond memory, transversal Cliﬀord operations

on the three-sheet block, and lattice surgery between blocks for non-Cliﬀord operations, are the

natural follow-up topics. Distance scaling at

= 10

12 in simulation would also extend the Λ

measurement to higher distances and tighten the asymptotic claim.

Acknowledgments

The three-sheet construction is due to [

]; the contribution of the present paper is the circuit-

level validation under hardware-realistic noise. The author thanks the Stim and PyMatching

maintainers for the open-source tooling on which this work depends.

Code and Data Availability

The simulation scripts used for this work are released under the MIT license. Direct links:

• fcc_code.py

— FCC lattice construction, sheet edge enumeration, weight-4 stabilizer

generation, parity-check matrix assembly in GF(2), and CSS validity veriﬁcation.

• verify_construction.py

— algebraic veriﬁcation of the construction parameters

rank(H

), rank(H

), and CSS validity at L = 4, 6, 8 (reproduces Table 1).

• multiplex_threshold.py

— threshold sweep at

= 3

11 with and without the

three-sheet multiplex idle penalty (reproduces Figure 2).

• 3sheet_distance_scaling.py

— the central distance-scaling experiment at

= 4

with the multiplex idle penalty applied (reproduces Figure 3 and Tables 2 and 3).

• surface_code_baseline.py

— rotated surface code [[16, 1, 4]] under matched circuit-level

noise, providing the per-logical baseline cited in Section 7 and Table 4.

• build_construction_fig.py

— reproduces the cuboctahedral / triad-sheet schematic of

Figure 1.

• make_figures.py

— regenerates all three ﬁgures with TrueType-embedded fonts (single

entry point useful for re-rendering all plots in one step).

• requirements.txt

— pinned dependency versions:

stim>=1.15

pymatching>=2.3

numpy>=1.24

matplotlib>=3.7. Tested under Python 3.10 and 3.11 on Linux.

Each script is self-contained and writes its output ﬁgures and tabulated results to disk. Run-time

on a single modern CPU is approximately 1 minute for the threshold sweep, 5 minutes for the

distance-scaling experiment, and a few seconds each for the static-veriﬁcation and surface-code-

baseline scripts. A tagged release of these ﬁles will be archived with a Zenodo DOI prior to

publication.

Competing Interests

The author is employed by IDrive Inc. The following U.S. provisional patent applications, all

naming Raghu Kulkarni as inventor and assigned to IDrive Inc., are on ﬁle:

•

No. 64/029,144 (April 3, 2026): “Method and System for Quantum Error Correction Using

Triad Sheet Decomposition of the Face-Centered Cubic Lattice with Weight-4 Stabilizers on

Planar K ≥ 4 Quantum Processors.”

•

No. 64/015,757 (March 24, 2026): “Method and System for Tunable-Distance Quantum

Error Correction at 29% Encoding Rate on a Face-Centered Cubic Lattice via Periodic Flag

Parity Measurements at Tetrahedral Voids.”

•

No. 64/014,145 (March 23, 2026): “System and Method for Generating, Scaling, and Decoding

a High-Rate CSS Quantum Error Correction Code on a Face-Centered Cubic Lattice Using

Triadic Orthogonal Calculus.”

•

No. 64/014,153 (March 23, 2026): “Quantum Associative Memory on a Face-Centered Cubic

Error-Correcting Lattice.”

•

No. 64/008,866 (March 18, 2026): “Method of Manufacturing a Quantum Processor with

Face-Centered Cubic Connectivity from Three Stacked Planar Hexagonal Chip Layers.”

•

No. 64/008,236 (March 17, 2026): “Quantum Error Correction System and Method Using

Face-Centered Cubic Lattice Topology with Tetrahedral Defect-Based Logical Qubits and

Passive Peierls Error Suppression.”

References

[1]

R. Kulkarni, A 67%-Rate CSS Code on the FCC Lattice: [[192

130

3]] from Weight-12

Stabilizers, arXiv:2603.20294 (2026). https://arxiv.org/abs/2603.20294

[2]

R. Kulkarni, A [[

L, L

]] CSS Code from the FCC Lattice with Weight-4 Stabilizers and

= 4 Connectivity, Zenodo, doi:10.5281/zenodo.19412464 (2026).

https://doi.org/10.

5281/zenodo.19412464

[3]

O. Higgott, PyMatching: A Python package for decoding quantum codes with minimum-weight

perfect matching, ACM Trans. Quantum Comput. 3, 1 (2022).

https://doi.org/10.1145/

3505637

[4]

C. Gidney, Stim: a fast stabilizer circuit simulator, Quantum 5, 497 (2021).

https://doi.

org/10.22331/q-2021-07-06-497

[5]

R. Acharya et al. (Google Quantum AI), Quantum error correction below the surface code

threshold, Nature 638, 920 (2024). https://doi.org/10.1038/s41586-024-08449-y

[6]

A. G. Fowler, M. Mariantoni, J. M. Martinis, A. N. Cleland, Surface codes: Towards practical

large-scale quantum computation, Phys. Rev. A 86, 032324 (2012).

https://doi.org/10.

1103/PhysRevA.86.032324

[7]

S. Bravyi, A. W. Cross, J. M. Gambetta, D. Maslov, P. Rall, T. J. Yoder, High-threshold and

low-overhead fault-tolerant quantum memory, Nature 627, 778 (2024).

https://doi.org/10.

1038/s41586-024-07107-7

[8]

B. M. Reichardt et al. (Atom Computing, Microsoft Azure Quantum), Logical computation

demonstrated with a neutral atom quantum processor, arXiv:2411.11822 (2024).

https://

arxiv.org/abs/2411.11822