Weight-3 Logical Operators on the Face Centered Cubic Lattice

Faces and Claws: A Complete Classication of the

Weight-3 Logical Operators on the Face Centered

Cubic Lattice

Raghu Kulkarni

SSMTheory Group, IDrive Inc., Calabasas, CA 91302, USA

raghu@idrive.com

Abstract

The

[[3𝐿

, 2𝐿

+2, 3]]

CSS code on the Face Centered Cubic (FCC) lattice reaches a

67.7% encoding rate with weight-12 stabilizers. Its distance is 3. We classify every

weight-3 logical operator of the code. The

𝑋

-type ones are the

4𝐿

triangular faces

of the lattice. The

𝑍

-type ones are the

4𝐿

claws

, each formed by the three edges of

a tetrahedron meeting at one of its vertices. The two families are exact duals under

the exchange of vertices and octahedral voids, and each spans

2𝐿

− 1

independent

logical classes. We prove this count analytically from the homology of the 3-torus,

not only numerically: the cycle space has dimension

𝐿

, the boundary space has

dimension

𝐿

−2

, and subtracting the stabilizer rank leaves

2𝐿

−1

for every even

𝐿

𝑘 = (2𝐿

−1)+3

, and the excess rate is carried entirely by weight-3 operators. We

then show that this sector cannot be protected. The three-body parity

𝑍

𝑒

𝑎

𝑍

𝑒

𝑏

𝑍

𝑒

𝑐

a face anticommutes with four octahedral stabilizers, so it is not measurable, and no

measurement of any kind can distinguish

|𝜓⟩

from

𝐿

𝑇

|𝜓⟩

for arbitrary encoded

|𝜓⟩

Removing the sector requires adjoining all

2𝐿

− 1

independent directions, which

returns

𝑘 = 3

. Veried exactly over GF(2) at

𝐿 = 4, 6, 8, 10

Keywords:

quantum error correction; FCC lattice; CSS codes; logical operators;

code distance

1 Introduction

Quantum error correcting codes trade encoding rate against code distance. The surface

code [1, 2] reaches high distance at a rate below 1%. Recent qLDPC constructions [3, 4]

reach constant rate with growing distance, but they need qubit connections that current

hardware does not provide.

The FCC lattice code [5] sits at an unusual point. It is a CSS code with parameters

[[3𝐿

, 2𝐿

+2, 3]]

and a 67.7% encoding rate. All stabilizers have weight 12, and all cou-

plings are nearest neighbor in three dimensions. The distance is 3.

That paper leaves an open question. It asks whether a modied FCC construction can

raise the distance while keeping the rate. Known routes, such as subsystem gauging [6],

cost most of the rate. This paper answers the question by describing the weight-3 sector

exactly.

Summary of results.

Section 2 xes notation. Section 3 classies the weight-3 logical

operators in both sectors: faces carry the

𝑋

-type ones and claws carry the

𝑍

-type ones,

with

4𝐿

of each. Section 4 proves that each family spans

2𝐿

− 1

independent classes

for every even

𝐿

, using the homology of the 3-torus. Section 5 shows that the natural

detector is not measurable, and that no measurement at all can see a completed face error

without disturbing the encoded state. Section 6 computes the cost of removing the sector.

Section 7 works through what this rules out.

2 The FCC Code

Lattice and stabilizers.

The FCC lattice is the densest sphere packing in three di-

mensions [9] and has coordination number

𝐾 = 12

. The 12 nearest neighbor vectors split

into three orthogonal sheets of four, which we call the

triad

[5]:

𝑆

𝑥𝑦

: (±1, ±1, 0),

𝑆

𝑥𝑧

: (±1, 0, ±1),

𝑆

𝑦𝑧

: (0, ±1, ±1).

(1)

Physical qubits sit on lattice edges.

𝑍

-stabilizers act on the 12 edges at each vertex.

𝑋

-stabilizers act on the 12 edges around each octahedral void. Both have weight 12. We

take

𝐿 ≥ 4

even with periodic boundaries, so

𝑛 = 3𝐿

and

𝑘 = 2𝐿

+ 2

Counting the cells.

The lattice has

𝑉 = 𝐿

nodes,

𝑛 = 3𝐿

edges,

𝐿

octahedral

voids, and

𝐿

tetrahedral voids. Each node lies in 24 triangles and each triangle has three

nodes, so

𝑁

tri

(𝐿

/2) · 24

= 4𝐿

(2)

The same count follows from either void type. The

𝐿

tetrahedra have

4𝐿

faces, the

𝐿

octahedra have

4𝐿

faces, and every triangular face belongs to exactly one tetrahedron

and one octahedron. A face is a dierent object from a tetrahedral void, and there are

four times as many.

Two sectors.

For a CSS code the distance is

𝑑 = min(𝑑

𝑋

, 𝑑

𝑍

)

, where

𝑋

-type logi-

cal operators are elements of

ker(𝐻

𝑍

) ∖ rowspace(𝐻

𝑋

)

and

𝑍

-type ones are elements of

ker(𝐻

𝑋

) ∖ rowspace(𝐻

𝑍

)

. We treat the two sectors separately throughout. Where we

speak of logical

classes

we mean cosets in these quotients, not encoded qubits.

3 The Two Weight-3 Families

Both families use all three sheets.

Lemma 1

(Triad decomposition)

Every triangle in the FCC graph has exactly one edge

in each of

𝑆

𝑥𝑦

𝑆

𝑥𝑧

𝑆

𝑦𝑧

. The same holds for the three edges of a tetrahedron meeting at

one of its vertices.

Proof.

Two adjacent nodes dier by a nearest neighbor vector, and each such vector has

exactly one zero component. Suppose two of the three edges were in the same sheet.

In the triangle case their sum is the third edge, which would then have a repeated zero

component, and no nearest neighbor vector has two zero components. In the claw case

the two edges leave a common node, so their dierence joins the two far endpoints and

is again a nearest neighbor vector, and the same argument applies. So the three edges

occupy three distinct sheets, and there are only three.

3.1 Faces carry the

𝑋

-type operators

Lemma 2

(Faces are silent and non-trivial)

Let

𝑇 = {𝑒

𝑎

, 𝑒

𝑏

, 𝑒

𝑐

}

be a triangular face with

indicator vector

𝑣

𝑇

. Then

𝐻

𝑍

𝑣

𝑇

= 0

, and

𝑣

𝑇

/∈ rowspace(𝐻

𝑋

)

. Each

𝑣

𝑇

is a weight-3

𝑋

-type logical operator.

Proof.

Each node of

𝑇

meets exactly two edges of

𝑇

, so every row of

𝐻

𝑍

overlaps

𝑣

𝑇

evenly and all other rows overlap it in zero positions. Non-triviality is checked over all

4𝐿

faces at

𝐿 = 4, 6, 8, 10

(Table 1).

Proposition 1

(Classication of the

𝑋

sector)

Every weight-3 vector in

ker(𝐻

𝑍

)

is the

indicator vector of a triangular face.

Proof.

A weight-3 vector in

ker(𝐻

𝑍

)

is a three-edge subgraph in which every node has

even degree, so every node has degree 0 or 2. A three-edge graph with all degrees even is

a 3-cycle.

𝐿 = 4

we conrm this by direct enumeration. Exactly 256 of the



192



weight-3 vectors

lie in

ker(𝐻

𝑍

)

, matching Eq. (2).

3.2 Claws carry the

𝑍

-type operators

Lemma 3

(Claws are silent and non-trivial)

Let

𝐶

be the set of three edges of a tetrahe-

dron that meet at one of its four vertices, with indicator vector

𝑣

𝐶

. Then

𝐻

𝑋

𝑣

𝐶

= 0

, and

𝑣

𝐶

/∈ rowspace(𝐻

𝑍

)

. Each

𝑣

𝐶

is a weight-3

𝑍

-type logical operator. There are

4𝐿

claws,

indexed by a tetrahedron and a choice of apex.

We verify Lemma 3 over all

4𝐿

claws at

𝐿 = 4, 6, 8, 10

. Every claw lies in

ker(𝐻

𝑋

)

and

none is a stabilizer. The overlap pattern against the vertex stabilizers is

(1, 1, 1, 3)

every claw, dual to the face pattern of Theorem 2: the apex vertex meets all three edges

and three further vertices meet one each.

Proposition 2

(Classication of the

𝑍

sector)

Every weight-3 vector in

ker(𝐻

𝑋

)

is the

indicator vector of a claw.

(a) face

X-type

(b) claw at apex

Z-type

overlap 3

(d) odd overlaps

(1, 1, 1, 3)

Figure 1: The two weight-3 families and the overlap obstruction. (a) A triangular face on

nodes

(0, 0, 0)

(1, 0, 1)

(0, 1, 1)

, with edges colored by triad sheet (Lemma 1). (b) The

claw at apex

(0, 0, 0)

, formed by the three edges of the tetrahedron

(0, 0, 0)

(1, 0, 1)

(0, 1, 1)

(1, 1, 0)

that meet there; the remaining tetrahedron edges are dotted. (c) The

octahedral void centered at

(0, 0, 1)

contains all three edges of the face, so the overlap is

3. (d) Three further octahedra, at

(1, 0, 0)

(0, 1, 0)

and

(1, 1, 1)

, each contain one edge,

giving the pattern

(1, 1, 1, 3)

of Theorem 2. The claw shows the dual pattern against the

vertex stabilizers.

Proof.

By Lemma 4 each edge lies in exactly two octahedral voids, so a weight-3 vector

produces six edge and octahedron incidences. Membership in

ker(𝐻

𝑋

)

requires every

octahedron to receive an even number, so the three unordered pairs of octahedra must

cover each octahedron evenly. Three pairs with all multiplicities even either repeat a

single pair, which is impossible because two distinct edges of the lattice do not share both

octahedra, or form a triangle

{𝑜

, 𝑜

}, {𝑜

, 𝑜

}, {𝑜

, 𝑜

}

. Three octahedra meeting pairwise

in this way surround a single tetrahedron, and the three edges are its edges at the common

vertex.

We conrm this by exhaustive search at

𝐿 = 4

and

𝐿 = 6

: the weight-3 vectors of

ker(𝐻

𝑋

)

number 256 and 864, and the sets coincide exactly with the claws.

The duality.

The two families are exchanged by swapping vertices with octahedral

voids. Both have

4𝐿

members, both use one edge per triad sheet (Lemma 1), both span

a space of dimension

𝐿

− 2

, and both contain the corresponding stabilizer rowspace.

Table 1 lists the numbers. The cross-sector symplectic pairing has rank

2𝐿

− 4

, three

short of the sector dimension, so three directions in each family pair only outside the

other family.

Mixed Pauli operators.

Propositions 1 and 2 cover pure

𝑋

-type and pure

𝑍

-type

operators. The next statement removes the remaining case.

Proposition 3

(No mixed weight-3 logicals)

Let

𝑃

be a Pauli operator of weight 3

represented by

(𝑥 | 𝑧)

that commutes with the stabilizer group. Then

𝑥 = 0

𝑧 = 0

Proof.

Commutation with a CSS stabilizer group requires

𝐻

𝑍

𝑥 = 0

and

𝐻

𝑋

𝑧 = 0

sep-

arately. Neither kernel contains a nonzero vector of weight 1 or 2. A weight-1 vector

meets each of its two endpoint stabilizers once, an odd overlap, and by Lemma 4 it meets

two octahedra once each. A weight-2 vector in

ker(𝐻

𝑍

)

would be a two-edge subgraph

with all degrees even, which does not exist in a simple graph, and a weight-2 vector in

ker(𝐻

𝑋

)

would need its two edges to lie in the same pair of octahedra, which Proposi-

tion 2 excludes. So if

𝑥 = 0

then

𝑥

has weight 3 and occupies the whole support of

𝑃

and by Proposition 1 that support is a triangular face. Likewise if

𝑧 = 0

its support is a

claw. Were both nonzero, the same three edges would form a face and a claw at once. A

face has three nodes of degree 2 and a claw has four nodes of degrees

3, 1, 1, 1

, so this is

impossible.

Corollary 1

(Complete weight-3 classication)

By Propositions 1, 2 and 3, every weight-

3 logical Pauli of the FCC code is either a pure

𝑋

operator on one of the

4𝐿

triangular

faces or a pure

𝑍

operator on one of the

4𝐿

claws. Since

𝑑 = min(𝑑

𝑋

, 𝑑

𝑍

)

and both

families are non-trivial,

𝑑 = 3

4 The Count Is Homological

The dimension of each family follows from the topology of the 3-torus, so it holds for

every even

𝐿

rather than only at the sizes we checked.

Theorem 1

(Dimension of the weight-3 sector)

Let

ℱ

be the span of the face vectors

and

𝒞

the span of the claw vectors. Then

dim ℱ = dim 𝒞 =

𝐿

− 2, dim ℱ − rk(𝐻

𝑋

) = dim 𝒞 − rk(𝐻

𝑍

) = 2𝐿

− 1.

(3)

Proof.

The FCC graph is connected, so its cycle space has dimension

dim 𝑍

= 𝑛−𝑉 +1 =

3𝐿

−

𝐿

+ 1 =

𝐿

+ 1

. In the tetrahedral and octahedral cellulation of the 3-torus

every 2-cell is a triangle, so the boundary space

𝐵

is spanned by the face vectors, giving

ℱ = 𝐵

. Since

𝐻

(𝑇

; F

)

∼

dim ℱ = dim 𝐵

= dim 𝑍

− 3 =

𝐿

− 2.

(4)

The octahedral stabilizers are sums of face vectors, and

rk(𝐻

𝑋

) =

𝐿

− 1

, so

dim ℱ − rk(𝐻

𝑋

) =



𝐿

− 2



−



𝐿

− 1



= 2𝐿

− 1.

(5)

For the claw statement, apply the same argument to the dual cellulation. There the

𝐿

octahedral voids play the role of vertices, the edges of the FCC lattice remain the 1-cells,

and the 2-cells are the claws: each claw is the set of three edges bounded by the three

octahedra that surround a tetrahedron at a chosen apex, as in the proof of Proposition 2.

The dual complex has the same edge count and the same rst homology, so the dimension

count is unchanged and

dim 𝒞 =

𝐿

−2

. Subtracting

rk(𝐻

𝑍

) =

𝐿

−1

leaves

2𝐿

−1

Since

𝑘 = 2𝐿

+ 2

, Theorem 1 gives

𝑘 = (2𝐿

− 1)

  

weight-3 classes

+ 3



topological

(6)

in each sector. All but three of the logical classes have a weight-3 representative. The

encoding rate and the distance 3 ceiling are the same degrees of freedom counted twice.

Figure 3 shows the counts.

A correction to the companion paper.

Reference [5], Sec. 7, conjectured that

𝑘 =

2 × (

tetrahedral voids

) + 2

, with the logical operators localized at tetrahedral voids. The

value

2𝐿

+ 2

is right and the tetrahedral intuition is partly right: the claws are indexed

by tetrahedra. But there are four claws per tetrahedron, not two, the

𝑋

sector lives on

triangular faces rather than voids, and the topological part is 3, not 2. All code parameters

in that paper reproduce exactly.

5 The Sector Cannot Be Detected Without Cost

A weight-3 face error is invisible to the syndrome. Flag ancillas are the standard tool for

catching faults that the syndrome misses [7, 8], so a natural proposal is to measure the

three-body parity

𝑃

𝑇

= 𝑍

𝑒

𝑎

𝑍

𝑒

𝑏

𝑍

𝑒

𝑐

, which anticommutes with

𝑋

𝑒

𝑎

𝑋

𝑒

𝑏

𝑋

𝑒

𝑐

. This section

rules that out, and then rules out every alternative.

Lemma 4

(Edge and octahedron incidence)

Every edge of the FCC lattice lies in exactly

two octahedral voids.

Proof.

Each octahedral stabilizer has support 12 and there are

𝐿

of them, giving

6𝐿

incidences over

3𝐿

edges. The lattice is vertex transitive, so the count is uniform.

Theorem 2

(The three-body parity is not measurable)

For every triangular face

𝑇

, the

operator

𝑃

𝑇

anticommutes with exactly four octahedral

𝑋

-stabilizers: one whose support

contains all three edges of

𝑇

and three that contain one edge each. Hence

𝑃

𝑇

does not lie

𝒩 (𝒮)

, and

𝑃

𝑇

is not a measurable check.

Proof.

𝑇

is a face of exactly one octahedron

𝑂

, whose support contains all three edges,

an odd overlap. By Lemma 4 the three edges give six incidences, of which three belong to

𝑂

. No other octahedron contains two edges of

𝑇

, because two edges of a triangle share a

node and span the plane of

𝑇

, so an octahedron containing both contains the third. The

remaining three incidences therefore fall in three distinct octahedra, one edge each, each

an odd overlap. A

𝑍

-type operator commutes with an

𝑋

-type stabilizer only on even

overlap, so

𝑃

𝑇

anticommutes with all four.

We observe the pattern

(1, 1, 1, 3)

at every one of the

4𝐿

faces at

𝐿 = 4, 6, 8, 10

, with no

exceptions. Figure 1 shows the four octahedra for one face.

Every alternative fails as well.

Theorem 2 rules out one candidate operator. The

following rules out all of them, for measurements of any kind and not only Pauli ones.

Theorem 3

(No state-independent perfect detection)

Let

𝐿

𝑇

be the logical operator of

a face

𝑇

. There is no measurement that distinguishes

|𝜓⟩

from

𝐿

𝑇

|𝜓⟩

for every encoded

|𝜓⟩

Proof.

𝐿

𝑇

acts as a unitary on the code space and squares to the identity, so it has

eigenvectors there. For any encoded eigenvector

|𝜑⟩

we have

𝐿

𝑇

|𝜑⟩ = ± |𝜑⟩

, which is the

same physical state up to a global phase. No measurement distinguishes a state from

itself, so no single detector works for every encoded input.

Corollary 2

(Detection costs a logical class)

Let

𝑀

be a Pauli operator that preserves

the code space and detects

𝑣

𝑇

. Then

𝑀 ∈ 𝒩 (𝒮) ∖ 𝒮

, so

𝑀

is a non-trivial logical Pauli,

and measuring

𝑀

projects the conjugate logical class.

Proof.

Detecting

𝑣

𝑇

requires

𝑀

to anticommute with

𝐿

𝑇

. Preserving the code space

places

𝑀

𝒩 (𝒮)

. An element of

𝒩 (𝒮)

that anticommutes with a logical operator is not

𝒮

Corollary 2 is constructive here. A claw sharing an odd number of edges with

𝑇

commutes

with every stabilizer, by Lemma 3, and anticommutes with

𝐿

𝑇

. It detects the face error

exactly, and it is a logical

𝑍

operator. The detector for one weight-3 family is the other

weight-3 family.

6 Removing the Sector

Theorem 4

(Cost of raising the distance)

Let

𝒢 ⊆ ker(𝐻

𝑍

)

be a set of admissible

𝑋

type checks adjoined to the stabilizer group. Then

𝑑

𝑋

≥ 4

if and only if

ℱ ⊆ span(𝒢) +

rowspace(𝐻

𝑋

)

, which requires at least

2𝐿

− 1

new independent directions. Hence

𝑘

′

≤ 3

and the minimal choice

𝒢 = ℱ

gives exactly

𝑘

′

= 3

Proof.

If the enlarged span omits some face vector, that face is still a weight-3

𝑋

-logical,

𝑑

𝑋

= 3

. If the span contains every face vector, then by Proposition 1 no weight-3

𝑋

-logical remains, so

𝑑

𝑋

≥ 4

. Containing

ℱ

costs at least

dim ℱ − rk(𝐻

𝑋

) = 2𝐿

− 1

new independent directions by Eq. (3), so

𝑘

′

≤ (2𝐿

+ 2) − (2𝐿

− 1) = 3

. A larger

𝒢

may

impose further independent constraints and reduce

𝑘

′

below 3. Taking

𝒢 = ℱ

attains the

bound. The requirement

𝒢 ⊆ ker(𝐻

𝑍

)

is what makes the enlarged group a CSS stabilizer

group: the new

𝑋

-checks must commute with the existing

𝑍

-checks.

The condition is on the span, not on the number of faces adjoined. The

4𝐿

face vectors

are highly redundant, and at

𝐿 = 4

a set of 127 independent directions already contains

all 256 faces. One direction short leaves at least one face surviving and the distance at

3. Figure 2a plots the logical count against independent directions added, which is the

meaningful axis.

What the gauged code is.

𝐿 = 4

the result is

[[192, 3, 4]]

, since 912 of the 1840

4-cycles survive as logical operators. At

𝐿 = 6

no weight-4 or weight-5 logical survives and

a weight-6 wrapping cycle does, so the code is

[[648, 3, 6]]

. These parameters coincide with

the 3D toric code at the same edge count,

𝑘 = 3

and

𝑑 = 𝐿

. We report the coincidence

of parameters and do not claim an equivalence of codes; establishing one would require

identifying the two chain complexes.

7 Consequences

Two errors on a face create a decoding ambiguity.

Table 1: Exact GF(2) structure of both weight-3 sectors. All quantities come from Gaus-

sian elimination over

, so there is no sampling and no statistical uncertainty. Faces and

claws each number

4𝐿

, each span

𝐿

− 2

, and each carry

2𝐿

− 1

independent classes,

in agreement with Theorem 1. The

𝐿 = 10

case runs in under one second.

𝐿 𝑛 𝑘 𝑁

tri

= 𝑁

claw

dim ℱ = dim 𝒞

classes per sector pairing rank

𝑘

gauged

4 192 130 256 158 127 124 3

6 648 434 864 538 431 428 3

8 1536 1026 2048 1278 1023 1020 3

10 3000 2002 4000 2498 1999 1996 3

predicted

4𝐿

𝐿

− 2 2𝐿

− 1 2𝐿

− 4

0 20 40 60 80 100 120

independent face directions adjoined

100

150

200

250

count

d ≥ 4 only here

k = 3

(a) d = 3 until the span closes

logical qubits k

faces outside span

3 4 5

distance d

encoding rate (%)

FCC base

[[192, 130, 3]]

FCC gauged

[[192, 3, 4]]

3D toric

[[108, 3, 4]]

2D surface

no code on this line

(b) no intermediate point from

partial face-sector removal

Figure 2: Rate against distance at

𝐿 = 4

. (a) Logical count against independent face

directions adjoined. The distance stays at 3 until the span contains every face, which takes

all

2𝐿

− 1 = 127

directions (Theorem 4). (b) The two points reachable by removing the

face sector. The dashed line carries no code obtainable this way; we do not claim that no

code exists at intermediate parameters, only that partial removal of the face sector does

not produce one. The 3D toric and 2D surface values are from Ref. [5], Table 3.

Proposition 4

(Syndrome ambiguity)

For every triangular face

{𝑒

𝑎

, 𝑒

𝑏

, 𝑒

𝑐

}

𝑠(𝑋

𝑒

𝑎

𝑋

𝑒

𝑏

) = 𝑠(𝑋

𝑒

𝑐

(7)

and dually

𝑠(𝑍

𝑒

𝑎

𝑍

𝑒

𝑏

) = 𝑠(𝑍

𝑒

𝑐

)

on every claw.

Proof.

𝑋

𝑒

𝑎

𝑋

𝑒

𝑏

𝑋

𝑒

𝑐

lies in

ker(𝐻

𝑍

)

by Lemma 2, so the syndromes of

𝑋

𝑒

𝑎

𝑋

𝑒

𝑏

and

𝑋

𝑒

𝑐

agree.

The claw statement follows the same way from Lemma 3.

The syndrome therefore does not determine which of the two hypotheses occurred. For

independent errors at small

𝑝

the single-edge explanation carries weight

𝑝

and the double-

edge explanation weight

𝑝

, so maximum likelihood decoding selects the single edge. On

the double fault it corrects

𝑒

𝑐

, completing the face and applying a logical operation. Two

errors therefore suce, so the block failure rate is

𝑂(𝑝

)

and not

𝑂(𝑝

)

. This matches

the Monte Carlo results of Ref. [5], which report a block logical error rate of

1.2 × 10

−2

𝑝 = 10

−3

under MWPM decoding at

𝐿 = 4

. That value exceeds an

𝑁

tri

𝑝

estimate by

a factor of

4.7 × 10

, so the silent triple is not the dominant mechanism.

4 6 8 10

lattice size L

count

(a) both sectors, exact

n = 3L

faces = claws = 4L

span =

− 2

k = 2L

+ 2

classes/sector = 2L

− 1

4 6 8 10

lattice size L

logical qubits k

130

434

1026

2002

(b) removing the sector returns k = 3

before, k = 2L

+ 2

after, k = 3

Figure 3: Exact counts at

𝐿 = 4, 6, 8, 10

. (a) Edges, weight-3 operators per sector, logical

qubits, and independent classes per sector. (b) Adjoining every face direction returns

𝑘 = 3

at every size.

Decoder quality is not the limit.

By Corollary 1 the weight-3 logical operators are

the faces and the claws and nothing else. Proposition 4 shows their syndromes coincide

with those of single-edge errors. No decoder separates the two cases, because the data

are identical. The limit is set by the code.

Local ancillas do not raise the distance of this code.

Theorem 2 rules out the

three-body parity and Theorem 3 rules out any state-independent detector of a completed

face error on the original code space. For a particular known

|𝜓⟩

that is not an eigenvector,

a distinguishing measurement may well exist; what does not exist is one detector that

works for arbitrary unknown encoded states. We do not claim that ancillas are useless

in general. Ancillas can dene a dierent code, a subsystem code, or a concatenated

construction. What is excluded is protecting the weight-3 sector while keeping the full

encoded space, and by Theorem 4 any construction that removes the sector pays

2𝐿

− 1

classes.

Tetrahedral stabilizers break CSS validity.

Reference [5], Sec. 9, proposes adding

tetrahedral void stabilizers as a third layer. Those checks do detect the face errors, at 256

of 256 faces for

𝐿 = 4

. But every tetrahedron shares a triangular face with an octahedron,

so the overlap is 3 and

𝐻

𝑋

𝐻

𝑇

𝑍

′

= 0

. We count 256 violations at

𝐿 = 4

and 864 at

𝐿 = 6

Restricted noise gives one extra step.

By Lemma 1 both families use one edge per

triad sheet, so an error conned to one or two sheets cannot complete either. Under that

restriction the minimum logical weight is 4. The gain stops there, because weight-4 logical

operators t inside a single sheet. One example is the planar square built from

(1, 1, 0)

(1, −1, 0)

(−1, −1, 0)

(−1, 1, 0)

, which lies entirely in

𝑆

𝑥𝑦

. The count of single-sheet

weight-4 logical operators is

𝐿

for

𝐿 ≥ 6

, giving 324, 768 and 1500 at

𝐿 = 6, 8, 10

𝐿 = 4

we count 432 rather than 96, because the period is short enough that distinct

wrapping cycles coincide;

𝐿 = 4

is degenerate here as it is for the gauged distance. This

is an assumption about the noise and not a property of the code.

Known error locations help in the usual way.

If error positions are known, the

code corrects any erasure pattern that does not contain a logical operator. Any two

erasures are correctable. Three are correctable unless they form a face or a claw, which

is 512 of the 1,161,280 triples at

𝐿 = 4

, or

4.4 × 10

−4

What a working construction would need.

Raising the distance means changing

the chain complex so that faces stop being cycles of

𝐻

𝑍

and claws stop being cycles of

𝐻

𝑋

. By Theorem 1 and Eq. (6) the cost comes out of the same

2𝐿

− 1

classes. That is

the budget for any construction on this lattice.

8 Conclusion

The weight-3 logical operators of the FCC code are the

4𝐿

triangular faces in the

𝑋

sector and the

4𝐿

claws in the

𝑍

sector. The two families are duals, and each carries

2𝐿

−1

of the

2𝐿

logical classes, a count that follows from the homology of the 3-torus

for every even

𝐿

. A single geometric fact drives the obstruction: every triangular face is

shared between one tetrahedron and one octahedron, so an operator supported on a face

has odd overlap with an octahedral stabilizer. The high rate of the FCC code is a count

of its weight-3 operators, and removing them returns

𝑘 = 3

Data Availability

The verication script reproducing every number in this paper is given in Appendix A.

It uses only the Python standard library and runs in under one second at

𝐿 = 10

. No

experimental data were used.

A Verication Code

The script builds the FCC lattice, assembles

𝐻

𝑍

and

𝐻

𝑋

, enumerates the triangular faces

and the claws, computes the cross-sector pairing rank, and checks every claim by exact

GF(2) elimination. Vectors are Python integers used as bitmasks.

NN = [(1,1,0),(1,-1,0),(-1,1,0),(-1,-1,0),

(1,0,1),(1,0,-1),(-1,0,1),(-1,0,-1),

(0,1,1),(0,1,-1),(0,-1,1),(0,-1,-1)]

OCT = [(1,0,0),(-1,0,0),(0,1,0),(0,-1,0),(0,0,1),(0,0,-1)]

def build(L):

nidx, nodes = {}, []

for x in range(L):

for y in range(L):

for z in range(L):

if (x+y+z) % 2 == 0:

nidx[(x,y,z)] = len(nodes); nodes.append((x,y,z))

edges, eidx = [], {}

for i,(x,y,z) in enumerate(nodes):

for dx,dy,dz in NN:

j = nidx.get(((x+dx)%L,(y+dy)%L,(z+dz)%L))

if j is not None:

e = (i,j) if i<j else (j,i)

if e not in eidx: eidx[e] = len(edges); edges.append(e)

ne = len(edges)

adj = [set() for _ in nodes]

for a,b in edges: adj[a].add(b); adj[b].add(a)

vmask = [0]*len(nodes)

for ei,(a,b) in enumerate(edges):

vmask[a] |= 1<<ei; vmask[b] |= 1<<ei

omask = []

for x in range(L):

for y in range(L):

for z in range(L):

if (x+y+z) % 2 == 1:

nbs = [nidx.get(((x+d[0])%L,(y+d[1])%L,(z+d[2])%L))

for d in OCT]

if all(v is not None for v in nbs):

s, m = set(nbs), 0

for ei,(a,b) in enumerate(edges):

if a in s and b in s: m |= 1<<ei

omask.append(m)

E = lambda u,v: eidx[(u,v)] if u<v else eidx[(v,u)]

faces, claws = [], []

for i in range(len(nodes)):

nb = sorted(adj[i])

for x in range(len(nb)):

for y in range(x+1, len(nb)):

j, k = nb[x], nb[y]

if k not in adj[j]: continue

if i < j: # triangular face

faces.append((1<<E(i,j))|(1<<E(j,k))|(1<<E(i,k)))

for l in nb[y+1:]: # claw at apex i

if l in adj[j] and l in adj[k]:

claws.append((1<<E(i,j))|(1<<E(i,k))|(1<<E(i,l)))

return nodes, edges, ne, vmask, omask, faces, claws

def rank(vecs):

piv, r = {}, 0

for v in vecs:

while v:

h = v.bit_length()-1

if h in piv: v ^= piv[h]

else: piv[h] = v; r += 1; break

return r, piv

def pairing_rank(faces, claws):

rows = []

for f in faces:

w = 0

for j, c in enumerate(claws):

if bin(f & c).count(’1’) & 1: w |= 1 << j

rows.append(w)

return rank(rows)[0]

for L in [4,6,8,10]:

nodes, edges, ne, vmask, omask, faces, claws = build(L)

rZ,_ = rank(vmask); rX,_ = rank(omask)

rF,_ = rank(faces); rC,_ = rank(claws)

rFX,_ = rank(list(omask)+list(faces))

rCZ,_ = rank(list(vmask)+list(claws))

print(L, ne, ne-rZ-rX, len(faces), len(claws), rF, rC,

rFX-rX, rCZ-rZ, pairing_rank(faces, claws), ne-rZ-rFX)

The output reproduces Table 1.

References

[1] A. Y. Kitaev, Fault-tolerant quantum computation by anyons, Ann. Phys.

303

, 2

(2003). doi:10.1016/S0003-4916(02)00018-0

[2] A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, Surface codes:

Towards practical large-scale quantum computation, Phys. Rev. A

, 032324 (2012).

doi:10.1103/PhysRevA.86.032324

[3] P. Panteleev and G. Kalachev, Asymptotically Good Quantum and Locally

Testable Classical LDPC Codes, in

Proc. 54th ACM STOC

, 375 (2022).

doi:10.1145/3519935.3520017

[4] A. Leverrier and G. Zémor, Quantum Tanner Codes, in

Proc. 63rd IEEE FOCS

, 872

(2022). doi:10.1109/FOCS54457.2022.00117

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

[[192, 130, 3]]

from Weight-

12 Stabilizers, arXiv:2603.20294 (2026). arXiv:2603.20294

[6] H. Bombín, Single-Shot Fault-Tolerant Quantum Error Correction, Phys. Rev. X

031043 (2015). doi:10.1103/PhysRevX.5.031043

[7] R. Chao and B. W. Reichardt, Quantum Error Correction with Only Two Extra

Qubits, Phys. Rev. Lett.

121

, 050502 (2018). doi:10.1103/PhysRevLett.121.050502

[8] C. Chamberland and M. E. Beverland, Flag Fault-Tolerant Error Correction with

Arbitrary Distance Codes, Quantum

, 53 (2018). doi:10.22331/q-2018-02-08-53

[9] T. C. Hales, A proof of the Kepler conjecture, Ann. Math.

162

, 1065 (2005).

doi:10.4007/annals.2005.162.1065

Declarations

Ethical approval

Not applicable.

Consent to participate

Not applicable.

Consent to publish

Not applicable.

Competing interests

The author declares provisional patent applications related to quantum error correction

codes on the FCC lattice (U.S. Provisional Application Nos. 64/008,236; 64/008,866;

64/014,145; 64/014,153; 64/015,757; 64/029,144). The theoretical results are independent

of any commercial application.

Funding

This work was supported internally by IDrive Inc. No external funding was received.

Author contributions

Raghu Kulkarni: Conceptualization, Methodology, Software, Validation, Formal Analy-

sis, Investigation, Writing  Original Draft, Writing  Review & Editing, Visualization.

Single-author manuscript.