Odd Majorana Codes: Fault Tolerance and Parity

• Odd Majorana codes are defined by features such as odd logical operators, parity constraints, and codes designed to address odd-weight errors.
• The formulation relies on parity-even stabilizer frameworks where oddness shifts to the logical algebra, enhancing protection via superselection rules.
• Implementations require specialized fault-tolerance gadgets and parity-relative control to effectively encode and correct odd-weight errors in Majorana systems.

“Odd Majorana codes” is not a single standardized term in the arXiv literature. Across Majorana-code, fermionic-code, and Majorana-zero-mode papers, it refers to several nearby but distinct structures: codes with odd logical operators, codes whose dominant target noise is odd-weight Majorana error, codes defined by whether total fermion parity is or is not included in the stabilizer group, and encodings built from an odd number of Majorana zero modes. What unifies these usages is the central role of fermion-parity superselection: in most physical stabilizer frameworks, stabilizers remain parity even, while “oddness” reappears in the logical algebra, in the error model, or in the representation theory of the Majorana operator algebra (Bravyi et al., 2010).

1. Terminological scope

The phrase is best understood by separating several meanings that are often conflated.

Meaning	Precise content	Representative source
Odd logical code	A Majorana code with at least one odd logical operator	(Bravyi et al., 2010)
Odd code in parity language	A code with total parity $P\notin S$	(Mudassar et al., 13 Aug 2025)
Code for odd-weight errors	A code designed to detect or correct parity-violating Majorana errors	(Vijay et al., 2017)
Odd-Majorana-mode encoding	A physical system with an odd number of Majorana zero modes	(Jackiw et al., 2011)

The first usage is the most established in the early Majorana-code literature. In “Majorana Fermion Codes,” a code has an odd logical operator exactly when the total parity operator $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$ is not contained in $\pm{\cal S}_{\rm maj}$; the paper packages this through the parameter $k_{\rm odd}\in\{0,1\}$ and ties the phenomenon to fermionic superselection protection (Bravyi et al., 2010). A later fault-tolerance framework makes the same distinction more explicitly by definition: an even code satisfies $P\in S$, whereas an odd code satisfies $P\notin S$ (Mudassar et al., 13 Aug 2025).

A second usage is error-model centered rather than logical-algebra centered. In “Quantum Error Correction for Complex and Majorana Fermion Qubits,” odd Majorana operators are the parity-violating errors, especially single-Majorana quasiparticle-poisoning events $\gamma_j$, and the code-theoretic question is how to detect or correct them with even stabilizers (Vijay et al., 2017). A third usage concerns the representation theory of Majorana zero modes themselves: for $N$ vortices, odd $N$ requires a parity-preserving state space of dimension $2^{(N+1)/2}$, not the naive $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$0, so oddness here refers to the number of physical Majorana modes rather than to stabilizer weight or logical parity (Jackiw et al., 2011).

This suggests that “odd Majorana code” should be parsed locally from context rather than treated as a fixed term of art.

2. Stabilizer formalism and the parity-even baseline

The dominant stabilizer formalism for Majorana codes is parity even. Majorana operators satisfy the standard Clifford algebra, for example $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$1 or $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$2, depending on notation, and stabilizer groups are built from commuting even Majorana monomials (Vijay et al., 2017). In the binary description, this is equivalent to requiring stabilizer vectors to be self-orthogonal and therefore of even Hamming weight (Bettaque et al., 2024).

This restriction is not merely conventional. In the 2024 structural analysis of the Majorana Clifford group, physical observables and stabilizers must lie in the even subgroup $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$3, because odd strings anticommute with fermion parity $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$4; odd strings remain meaningful as formal operators and may serve as logical operators, but not as physical stabilizer generators (Bettaque et al., 2024). The same point appears in “Majorana Fermion Codes,” where every element of $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$5 is required to have even weight (Bravyi et al., 2010).

A particularly clear parity-even regime is the one imposed in “Small Majorana Fermion Codes.” There the fermion-parity operator

$C_{\rm all}=i^n c_1c_2\cdots c_{2n}$6

is assumed to be in the stabilizer group, and the consequence is immediate: every logical operator must commute with $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$7, hence every logical operator has even Majorana weight, and the code distance is even and at least $C_{\rm all}=i^n c_1c_2\cdots c_{2n}$8 (Hastings, 2017). The paper’s distance-$C_{\rm all}=i^n c_1c_2\cdots c_{2n}$9 and distance-$\pm{\cal S}_{\rm maj}$0 constructions, including the Hamming-like family

$\pm{\cal S}_{\rm maj}$1

are therefore not odd codes in the logical-parity sense, even though some of them outperform qubit-derived Majorana codes (Hastings, 2017).

The same parity-even baseline persists in the surface-code and color-code framework for Majorana fermion codes. There, only even-number products of Majoranas are physically measurable, face stabilizers contain even numbers of Majoranas, and the Majorana code distance $\pm{\cal S}_{\rm maj}$2 is always even (Litinski et al., 2018). A common misconception is therefore that odd Majorana structure should show up as odd stabilizer generators; in the main stabilizer literature, it usually does not.

3. Odd logical operators and superselection protection

Once the stabilizer group is fixed to be parity even, oddness reappears most naturally in the logical operator algebra. The decisive criterion from “Majorana Fermion Codes” is:

$\pm{\cal S}_{\rm maj}$3

When this occurs, the code may be viewed as having $\pm{\cal S}_{\rm maj}$4, and one may choose logical Pauli representatives so that one of them is odd, for example $\pm{\cal S}_{\rm maj}$5 and $\pm{\cal S}_{\rm maj}$6 with $\pm{\cal S}_{\rm maj}$7 an odd logical operator (Bravyi et al., 2010). The physical significance is that odd logical operators are inaccessible to parity-preserving environments. The paper therefore introduces

$\pm{\cal S}_{\rm maj}$8

which measures the smallest support diameter of an even logical operator and hence the lowest-order parity-preserving process capable of splitting the degeneracy (Bravyi et al., 2010).

Kitaev’s chain is the canonical example. Its stabilizer group

$\pm{\cal S}_{\rm maj}$9

has odd logical operators $k_{\rm odd}\in\{0,1\}$0 and $k_{\rm odd}\in\{0,1\}$1, so $k_{\rm odd}\in\{0,1\}$2 as an abstract code but $k_{\rm odd}\in\{0,1\}$3, because the lowest even logical operator $k_{\rm odd}\in\{0,1\}$4 spans the chain (Bravyi et al., 2010). In two dimensions, the Majorana color code on a cylinder has odd boundary logical operators

$k_{\rm odd}\in\{0,1\}$5

together with an even logical string joining the boundaries, and the paper proves

$k_{\rm odd}\in\{0,1\}$6

while also showing that 2D still admits string-like even logical processes and therefore does not evade the usual no-go intuition against self-correction (Bravyi et al., 2010).

The operator-algebraic side of the same phenomenon appears in random interacting Majorana systems with only parity $k_{\rm odd}\in\{0,1\}$7 and time reversal $k_{\rm odd}\in\{0,1\}$8. There one can construct exact odd normalized zero modes $k_{\rm odd}\in\{0,1\}$9 satisfying

$P\in S$0

so the odd operator algebra survives at finite size as an exact conserved structure (Monthus, 2018). This does not by itself define a stabilizer code, but it furnishes a natural algebraic precursor for odd logical sectors.

4. Odd-weight errors and fermionic-error-correcting constructions

A second major line of work uses “odd Majorana” to mean odd-weight, parity-violating noise rather than odd logical operators. In “Quantum Error Correction for Complex and Majorana Fermion Qubits,” the total parity operator is

$P\in S$1

and any odd-weight Majorana operator anticommutes with $P\in S$2; single-Majorana poisoning $P\in S$3 is the basic local error channel (Vijay et al., 2017). Stabilizers remain even, but the code is designed so that odd errors produce distinct syndromes. For a non-degenerate $P\in S$4 code correcting all errors up to weight $P\in S$5,

$P\in S$6

and the fermionic Hamming bound reads

$P\in S$7

The same paper argues that any nontrivial code must be non-degenerate with respect to weight-1 odd errors, because single-Majorana poisoning events cannot share a syndrome unless they act only on removable ancilla degrees of freedom (Vijay et al., 2017).

Its shortest explicit example is the $P\in S$8 code on $P\in S$9 Majoranas, with five even stabilizers and odd logical Majoranas

$P\notin S$0

This is a useful illustration of both meanings of oddness at once: the stabilizers are even, the targeted physical errors are odd, and the logical Majoranas can also be odd (Vijay et al., 2017).

The tetron-based construction “Majorana qubit codes that also correct odd-weight errors” makes the same distinction operational. A tetron hosts four Majorana zero modes $P\notin S$1, with qubit Pauli representatives

$P\notin S$2

and complementary representatives

$P\notin S$3

The main result is that measurements spanning zero or two Majoranas per tetron are already sufficient to correct fermionic odd-weight errors; direct four-Majorana tetron-parity measurements are not required (Kundu et al., 2023). Starting from a bosonic code $P\notin S$4, the paper’s $P\notin S$5 construction produces a fermionic code

$P\notin S$6

by enlarging the stabilizer group so that each tetron parity operator $P\notin S$7 is generated from measurable stabilizers. In that sense, odd-error correction emerges from even-measurement hardware (Kundu et al., 2023).

5. Odd numbers of Majorana modes and parity-sensitive encodings

A third strand concerns systems with an odd number of Majorana zero modes. “State Space for Planar Majorana Zero Modes” shows that the minimal parity-preserving state-space dimension is

$P\notin S$8

so an odd number of physical Majoranas does not lead to an ill-defined Hilbert space; rather, it is naturally realized as an embedding into the next even Clifford representation, heuristically described as a “phantom vortex at infinity” (Jackiw et al., 2011). For $P\notin S$9, the physically accepted parity-preserving representation is two dimensional,

$\gamma_j$0

whereas a one-dimensional diagonal realization is rejected as parity violating (Jackiw et al., 2011). This matters for odd Majorana encodings because it separates the operator-algebra representation space from any later code subspace obtained by parity restriction.

A concrete parity-sensitive encoding appears in the Kitaev-chain qubit realized with superconducting circuits. There the nonlocal end fermion

$\gamma_j$1

defines two degenerate ground states $\gamma_j$2 and $\gamma_j$3 that lie in opposite parity sectors, and the assignment depends on whether the chain length $\gamma_j$4 is even or odd. In the charge-qubit realization,

$\gamma_j$5

while

$\gamma_j$6

This is not a full error-correcting code, but it is an explicit encoded Majorana qubit whose logical basis is parity resolved and whose parity labeling is itself odd/even sensitive (You et al., 2011).

These results imply that “odd Majorana code” can also refer, more loosely, to an encoding architecture in which odd cardinality or odd global parity materially affects the representation of the logical degrees of freedom, even before stabilizer coding enters.

6. Even versus odd codes in fault tolerance

The sharpest modern formulation of the distinction is the one used in the 2025 fault-tolerance framework for Majorana stabilizer codes. There an even code is defined by

$\gamma_j$7

and an odd code by

$\gamma_j$8

The odd case immediately implies the existence of odd-weight logical operators, and the paper states that there must be at least two such odd logicals (Mudassar et al., 13 Aug 2025). If one insists on keeping logicals local to individual code blocks, the natural elementary degree of freedom in an odd code is then a logical fermion, not a logical qubit. This is the same obstruction already visible in Kitaev-chain blocks: multi-block qubit encodings require Jordan–Wigner-type nonlocality, which is ill suited to transversal fault tolerance (Mudassar et al., 13 Aug 2025).

Parity superselection is the basic obstruction. Physical unitaries must preserve total fermion parity, so a standalone odd logical operator or an odd-code Hadamard is not directly physical. The paper resolves this with quantum reference frames. A parity-preserving version of an odd logical $\gamma_j$9 is written as

$N$0

and a reference-assisted Hadamard-like operation is

$N$1

which conjugates parity-preserving dressed logicals into one another (Mudassar et al., 13 Aug 2025). More elaborate ancilla-and-reference gadgets then realize odd-code analogues of CNOT-like transformations while keeping the global operation parity even.

The same paper also gives a Steane-inspired syndrome-extraction formula for Majorana codes,

$N$2

and points out a specifically odd-code issue: recovery on the data block may itself correspond to an odd-weight operation, so the correction must be implemented jointly with an ancilla that absorbs the parity change (Mudassar et al., 13 Aug 2025). It further exhibits an odd Majorana Reed–Muller construction $N$3 with a transversal fermionic $N$4-type gate, while emphasizing that the corresponding logical states can only be described coherently relative to a reference frame (Mudassar et al., 13 Aug 2025).

This places the present state of the subject in a clear hierarchy. Mainstream physical stabilizer frameworks remain parity even at the stabilizer level (Bettaque et al., 2024). Odd logical operators are nevertheless well defined and can yield superselection-enhanced protection (Bravyi et al., 2010). Odd-weight noise can be corrected with even stabilizers (Vijay et al., 2017). Odd code blocks, in the sense $N$5, require genuinely fermionic fault-tolerance gadgets rather than a direct import of qubit constructions (Mudassar et al., 13 Aug 2025). The resulting picture is not that odd Majorana codes violate the parity-even stabilizer paradigm, but that they relocate oddness from stabilizers to logical structure, error models, and parity-relative control.