Fermionic LDPC Code Memory

Updated 9 July 2026

Fermionic LDPC code memory is an error-protected architecture that stores logical information directly in fermionic modes secured by sparse, bounded parity checks.
It utilizes Majorana stabilizer formulations to combine ordinary code-distance protection with fermion-parity superselection, enhancing resistance to low-weight errors.
Recent constructions integrate self-dual CSS codes and particle-conserved encodings, achieving constant rate storage and demonstrable fault-tolerant performance.

Searching arXiv for recent and foundational work on fermionic LDPC code memories and related Majorana/code-phase results. Fermionic low-density parity-check code memory denotes an error-protected fermionic memory in which logical information is stored directly in fermionic modes and protected by sparse parity checks of bounded weight. In the Majorana-stabilizer formulation, the checks are commuting even-parity products of Majorana operators, so the memory combines ordinary code-distance protection with fermion-parity superselection; in later fermion-to-fermion architectures, such memories act as high-rate storage blocks whose states are transferred to fermionic color-code processors by lattice surgery. A related simulation-oriented construction uses LDPC parity-check matrices to store fixed-particle-number occupation vectors as compressed syndromes, emphasizing optimal qubit cost rather than a commuting-projector memory Hamiltonian (Bravyi et al., 2010, Xu et al., 21 Aug 2025, Cheng et al., 2023, Yin et al., 2024).

1. Majorana-stabilizer foundation

A system of $n$ complex fermionic modes can be described by $2n$ Hermitian Majorana operators $\gamma_i$ , $i=1,\dots,2n$ , obeying

$\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$

Products of Majoranas generate the group of Majorana operators,

$\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$

with weight $|\gamma_A|=|A|$ . A Majorana operator is even or odd according to whether $|A|$ is even or odd, and monomials satisfy

$\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$

The total fermion parity operator is

$P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$

These relations define the algebraic setting for Majorana fermion codes and, more generally, fermionic LDPC memories built from even-parity checks (Bravyi et al., 2010).

A Majorana fermion code is specified by an Abelian subgroup $2n$0 such that $2n$1 and every stabilizer has even weight. The code space is the common $2n$2 eigenspace of the stabilizers, the centralizer $2n$3 consists of all Majorana monomials commuting with $2n$4, and logical operators are the elements of $2n$5. For code parameters $2n$6, the distance is

$2n$7

If $2n$8 has $2n$9 independent generators, then the code encodes $\gamma_i$ 0 qubits. The existence of odd logical operators is controlled by fermion parity: an MFC has at least one odd logical operator iff $\gamma_i$ 1.

The LDPC condition is expressed directly in fermionic language. Majorana modes occupy sites of a lattice or, in nongeometric constructions, vertices of a sparse interaction graph, and local checks take the form

$\gamma_i$ 2

with bounded check weight and bounded participation of each mode in the set of checks. In geometric realizations, pairwise commutation follows from even overlaps $\gamma_i$ 3.

2. Protection mechanisms, distance measures, and two-dimensional limits

The defining physical motivation is protection against low-weight fermionic errors, namely operators acting on sufficiently small subsets of fermionic modes. When the environment conserves fermion parity, physically realizable evolutions and errors must be even Majorana operators. This produces a distinction between the ordinary distance $\gamma_i$ 4 and a superselection-sensitive length scale for even logicals,

$\gamma_i$ 5

The point is not merely that a logical operator has large weight, but that parity-preserving environments may forbid odd logicals outright, leaving only even logicals as physically relevant error channels (Bravyi et al., 2010).

The one-dimensional Kitaev chain gives the minimal example of this mechanism. For

$\gamma_i$ 6

the stabilizers are $\gamma_i$ 7, the logical operators may be chosen as $\gamma_i$ 8, $\gamma_i$ 9, and $i=1,\dots,2n$ 0, and the code has $i=1,\dots,2n$ 1 but $i=1,\dots,2n$ 2. This is the canonical instance in which ordinary distance is trivial while the even logical has macroscopic diameter.

In two dimensions, Bravyi, Terhal, and Leemhuis proposed a Majorana color code on a cylinder $i=1,\dots,2n$ 3. One Majorana mode is placed at each vertex of a trivalent graph with even-length face boundaries and odd-length boundary loops, and the face checks are

$i=1,\dots,2n$ 4

With appropriate phases $i=1,\dots,2n$ 5, the Hamiltonian

$i=1,\dots,2n$ 6

is a local commuting-projector Hamiltonian whose ground space is the code space. The odd boundary logicals are

$i=1,\dots,2n$ 7

and an even logical can be realized as a string of bilinears $i=1,\dots,2n$ 8 connecting the two boundaries. For a cylinder with circumference $i=1,\dots,2n$ 9 and separation $\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 0, the paper proves

$\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 1

A common misconception is that fermion-parity superselection alone yields a self-correcting two-dimensional memory. The 2010 analysis shows otherwise. In any 2D local MFC, there are string-like logical operators: either an even logical exists on a single strip of constant width, or there is a pair of odd logicals on disjoint strips whose product is an even logical supported on two strings. Consequently, logical transitions can be implemented by sequences of local even operators with energy cost $\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 2 at each step, so the energy barrier is $\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 3. The result is a two-dimensional no-go theorem for self-correction at finite temperature, even though parity superselection can still suppress odd processes (Bravyi et al., 2010).

3. Construction from self-dual CSS codes

A systematic fermion-to-fermion LDPC construction starts from a self-dual CSS code with qubit parity-check matrices $\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 4 satisfying

$\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 5

From this data one builds a block-diagonal Majorana check matrix

$\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 6

where each row $\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 7 of $\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 8 defines an even-parity $\{\gamma_i,\gamma_j\}=2\delta_{ij}I,\qquad \gamma_i^\dagger=\gamma_i.$ 9-type stabilizer

$\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 0

and each row of $\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 1 defines an even-parity $\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 2-type stabilizer

$\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 3

Even row weights guarantee even fermion parity, $\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 4 guarantees commutation within each species, and the two species act on disjoint Majorana sets. The LDPC sparsity of the fermionic memory is inherited directly from the LDPC sparsity of $\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 5 (Xu et al., 21 Aug 2025).

Logical operator vectors lie in

$\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 6

for each Majorana species. A logical complex fermion is then assembled from a pair of logical Majoranas,

$\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 7

The paper imposes an additional fermionic-statistics condition: all logical Majoranas in the memory should have odd weight and even pairwise overlap, so that the corresponding logical Majoranas anticommute appropriately when interfaced with a processor. To extract such odd-weight logicals, the authors generalize Gram–Schmidt orthogonalization to $\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 8 by repeatedly isolating an odd-weight vector and orthogonalizing the remaining basis vectors against it.

The existence criterion for at least one odd-weight logical in $\eta\,\gamma_A,\qquad \gamma_A:=\prod_{u\in A}\gamma_u,\qquad \eta\in\{\pm1,\pm i\},\qquad A\subseteq\{1,\dots,2n\},$ 9 is

$|\gamma_A|=|A|$ 0

This criterion is restrictive. Not all self-dual CSS LDPC codes are suitable fermionic memories: the paper states that some self-dual CSS codes, including the Kitaev Majorana code and unicycle codes tested there, lack odd-weight logicals and are therefore unsuitable for the proposed interface scheme. This point is structurally important because the resulting memory is not merely a qubit LDPC code rewritten in fermionic variables; it must also preserve logical fermionic statistics (Xu et al., 21 Aug 2025).

4. Memory–processor architecture and demonstrated performance

In the fermion-to-fermion architecture, the fermionic LDPC memory is the high-rate storage block, while logical operations are executed on fermionic color code processors. State transfer is performed by fermionic lattice surgery. If block $|\gamma_A|=|A|$ 1 contains the logical fermion to be moved and block $|\gamma_A|=|A|$ 2 is initialized in the logical vacuum, the protocol first measures

$|\gamma_A|=|A|$ 3

If the outcome is $|\gamma_A|=|A|$ 4, one applies

$|\gamma_A|=|A|$ 5

One then measures $|\gamma_A|=|A|$ 6; if the outcome is $|\gamma_A|=|A|$ 7, one applies

$|\gamma_A|=|A|$ 8

on both blocks. The net effect is to transfer the identity of the logical fermion from $|\gamma_A|=|A|$ 9 to $|A|$ 0 while preserving its state (Xu et al., 21 Aug 2025).

For the joint logical measurement, the paper introduces a merged code with ancillas. If the relevant logical Majorana on block $|A|$ 1 has weight $|A|$ 2, then the construction uses $|A|$ 3 ancilla Majorana modes, equivalently $|A|$ 4 ancilla complex fermions, and introduces $|A|$ 5 measurement stabilizers together with $|A|$ 6 gauge stabilizers such that their product equals $|A|$ 7. The $|A|$ 8-type stabilizers are left unchanged. The merged code contains $|A|$ 9 ancilla complex fermions and $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 0 new stabilizers, and, using subsystem code formalism, the paper states that the merging does not reduce the code distance. Fault-tolerant execution requires $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 1 rounds of noisy stabilizer measurements and decoding, followed by measurement of the ancilla complex fermions in the number basis to return to the original code spaces.

The instantiated code families include a bicycle code $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 2 with $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 3 physical complex fermions, $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 4 logical complex fermions, distance $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 5, and rate $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 6, as well as finite projective and Euclidean geometry examples constructed from self-dual CSS LDPCs. The paper contrasts these with fermionic color codes, which typically encode a single logical fermion per planar block and require $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 7 physical modes at distance $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 8, so $\gamma_A\gamma_B = (-1)^{|A|\cdot |B|+|A\cap B|}\gamma_B\gamma_A.$ 9. On that basis, the LDPC memories achieve constant rates while maintaining nontrivial distances.

Under the error model used for benchmarking, physical errors are single-fermion gates chosen independently with equal probability $P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 0 among $P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 1, $P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 2, and $P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 3. The memory protocol runs $P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 4 cycles of random errors, syndrome measurement, decoding, and correction, with

$P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 5

For the PG, EG, and bicycle $P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 6 examples, the reported scaling is

$P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 7

In a dynamical simulation, four logical fermions initialized in $P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 8 undergo repeated modules built from braid gates

$P := i^n\,\gamma_1\gamma_2\cdots\gamma_{2n}.$ 9

and conditional fermionic swaps. The error-corrected runs closely track the noiseless simulation, whereas uncorrected runs deviate significantly, which the paper presents as evidence of effective error suppression (Xu et al., 21 Aug 2025).

5. Particle-conserved LDPC encoding as compressed fermionic memory

A distinct but related use of LDPC memory language appears in particle-conserved linear encoding for fermionic simulation. Here the stored objects are occupation vectors

$2n$00

for an $2n$01-mode, $2n$02-particle sector of dimension

$2n$03

The information-theoretic lower bound on qubit cost is $2n$04, and the paper proves an upper bound

$2n$05

more tightly

$2n$06

Thus the qubit complexity is $2n$07, matching the lower bound up to a constant factor $2n$08 (Cheng et al., 2023).

The encoding is linear:

$2n$09

with dual code generator $2n$10 satisfying

$2n$11

Distinctness of weight-$2n$12 configurations is ensured by requiring that all even-weight codewords in $2n$13 have Hamming weight at least $2n$14. The Randomized Linear Encoder chooses $2n$15 in the range $2n$16, sets

$2n$17

and checks the even-kernel distance condition by random tests. The paper emphasizes that practical LDPC families such as Gallager constructions, together with toolboxes including AFF3CT and OpenFEC, provide sparse parity checks and polynomial-time decoders. At the same time, it notes an important limitation: the appendix baseline uses columns of weight $2n$18, so that baseline is not strictly LDPC-sparse.

The operator mapping is tailored to fermionic simulation. For binary vectors $2n$19,

$2n$20

This eliminates explicit $2n$21-strings in favor of signed projectors. Expectation values are reconstructed by the Fermionic Expectation Decoder, which applies a classical decoder $2n$22 to measurement outcomes in a single Clifford-transformed basis and post-selects configurations with $2n$23. For quantum chemistry Hamiltonians built from $2n$24- and $2n$25-body terms, the number of measurement bases is bounded by

$2n$26

The empirical demonstrations use variational quantum eigensolver instances. For LiH in STO-3G with $2n$27, the method encodes to $2n$28 qubits and achieves chemical accuracy with $2n$29 layers of a hardware-efficient ansatz, while the $2n$30-qubit Jordan–Wigner instance does not converge even with $2n$31 layers. For LiH in 6-31G with $2n$32, the problem is encoded to $2n$33 qubits and the compressed instance converges while the uncompressed $2n$34-qubit problem exhibits barren plateaus. For $2n$35 in 6-311G* with $2n$36, the encoding uses $2n$37 qubits and achieves chemical accuracy across bond lengths $2n$38–$2n$39 Å. This line of work is therefore best understood as an LDPC-coded fermionic memory for compressed simulation rather than as a commuting-projector Majorana memory Hamiltonian (Cheng et al., 2023).

6. Stable phases, misconceptions, and open problems

A separate question is when an LDPC code Hamiltonian defines a stable gapped phase of matter with robust ground-state degeneracy. For qubit stabilizer code Hamiltonians

$2n$40

the 2024 analysis proves stability under few-body perturbations when the code has LDPC structure, check soundness, and effective distance

$2n$41

If the perturbation $2n$42 has sufficiently small local strength

$2n$43

then the perturbed spectrum satisfies

$2n$44

with exactly $2n$45 eigenstates in the lower band and

$2n$46

The quasiadiabatic unitary connecting ground spaces is generated by $2n$47 with

$2n$48

For constant-rate codes with $2n$49, this yields a constant zero-temperature entropy density $2n$50 (Yin et al., 2024).

All formal proofs in that paper are written for qubit stabilizer codes, not fermionic ones. However, the argument is explicitly described as adaptable to fermionic LDPC Hamiltonians built from commuting even-parity checks, provided there is a fermionic analogue of check soundness, the perturbations are even-parity and few-body, and the relevant logical distance is defined for even-parity logicals. This suggests a principled route to zero-temperature stability for fermionic LDPC memories that are nongeometric or expander-like, although the paper does not supply a fully rigorous fermionic proof.

Two misconceptions therefore need to be separated. The first is that any fermionic LDPC memory is automatically self-correcting; this is false in two dimensions because local MFCs have string-like logical operators and $2n$51 energy barriers (Bravyi et al., 2010). The second is that phase-stability results for general LDPC Hamiltonians have already established thermal robustness for fermionic memories; they have not. The 2024 theorem is a $2n$52 statement about spectral stability, quasiadiabatic connectivity, and exponentially small ground-band splitting under static few-body perturbations (Yin et al., 2024).

The principal open problems are correspondingly structural. One direction is to construct asymptotically good fermionic LDPC families with constant rate, large distance, guaranteed odd-weight logical Majoranas, and efficient decoders. Another is to engineer interacting fermionic Hamiltonians that realize commuting even-weight checks with controllable locality and strength. Additional unresolved questions include finite-temperature thresholds, rigorous decoder performance, direct logical gates within fermionic LDPC memories without transfer to color-code processors, extensions of lattice surgery to more general operations, and the effect of odd processes such as single-electron poisoning when parity superselection is only approximate (Xu et al., 21 Aug 2025, Cheng et al., 2023).