---
title: Forney's Cubing Construction of Golay Codes
url: https://www.emergentmind.com/topics/forney-s-cubing-construction-of-golay-codes
type: topic
---

# Forney's Cubing Construction of Golay Codes

Forney's cubing construction provides a structured, algebraic method for generating the binary extended Golay code, an optimal $(24,12,8)$ linear code. This technique, first introduced by Forney in "Coset Codes II" (1988), assembles the length-24 codeword by composing three shorter, nested binary block codes of length 8, using a specific “cubing” operator. Recent work, notably Ji et al. [2602.01657], has revisited and refined this structural approach, demonstrating its connection to modern Polarization Adjusted Convolutional (PAC) codes and leveraging it for efficient decoding and lattice construction.

## 1. Overview of the Cubing Construction

Forney’s cubing construction synthesizes the $(24,12,8)$ extended Golay code by stacking three nested binary codes:
- $C_1 \supset C_2 \supset C_3$ on $\mathbb F_2^8$
- $C_1$: $(8,7,2)$ single-parity-check code
- $C_2$: $(8,4,4)$ code, specifically the first-order Reed–Muller code $\operatorname{RM}(1,3)$
- $C_3$: $(8,1,8)$ repetition code

A codeword is constructed as $(x, y, z) = (a + c,\, b + c,\, c)$ for $a \in C_1$, $b \in C_2$, and $c \in C_3$. This “cubing” creates a $24$-bit word, generating a $(24,12,8)$ code with the Golay parameters.

## 2. Generator Matrices for Component Codes

The construction depends on explicit generator matrices:

- $C_1$: 
  $$
  G^*(8,7) = \left[I_7\,|\,\mathbf{1}_7\right]
  $$
  where $I_7$ is the $7 \times 7$ identity matrix, and $\mathbf{1}_7$ is a column vector of ones.

- $C_2$ (Reed–Muller $\operatorname{RM}(1,3)$):
  Begin with $F_2^{\otimes 3}$ and select the four rows of weight $\geq 4$ to get
  $$
  G_8 = 
  \begin{bmatrix}
  1&1&1&1&0&0&0&0\\
  1&1&0&0&1&1&0&0\\
  1&0&1&0&1&0&1&0\\
  1&1&1&1&1&1&1&1
  \end{bmatrix}
  $$

- $C_2'$: A column-permutation $\pi_3 = [5, 4, 2, 3, 1, 6, 7, 8]$ of $C_2$ gives
  $$
  G_8' = 
  \begin{bmatrix}
  0&1&1&1&1&0&0&0\\
  1&0&0&1&1&1&0&0\\
  1&1&0&0&1&0&1&0\\
  1&1&1&1&1&1&1&1
  \end{bmatrix}
  $$

- $C_3$: The all-ones $(8,1,8)$ repetition code:
  $$
  G_{\mathrm{rep}} = [1\,1\,1\,1\,1\,1\,1\,1]
  $$

## 3. Algebraic Assembly of the Golay Generator

The full $(24,12,8)$ code is constructed via Kronecker products and block assembly. Let $S$ and $R$ be:
$$
S = 
\begin{bmatrix}
1 & 0 & 1 \\
0 & 1 & 1
\end{bmatrix}, \quad
R = [1\,1\,1]
$$
where $S$ generates the $(3,2,2)$ SPC code and $R$ the $(3,1,3)$ repetition code.

The large generator matrix is:
$$
\hat{G} = 
\begin{bmatrix}
S \otimes G_8 \\
R \otimes G_8'
\end{bmatrix}
=
\begin{bmatrix}
G_8 & 0 & G_8 \\
0 & G_8 & G_8 \\
\hline
G_8' & G_8' & G_8'
\end{bmatrix}
$$

The top two $4 \times 24$ blocks (from $S\otimes G_8$) correspond to the indices of $C_2$ and $C_1$; the bottom block (from $R\otimes G_8'$) encodes the “cube”-symmetry from $C_3$.

## 4. The Cubing Operator: Definition and Clarification

The cubing operator $\square$ is formally defined for nested codes $C_1 \supset C_2 \supset C_3 \subset \mathbb F_2^m$ as:
$$
\square(a, b, c) = (a + c,\, b + c,\, c) \in \mathbb F_2^{3m}
$$
with $a \in C_1$, $b \in C_2$, $c \in C_3$.

For $m=8$ (the Golay code case), this process precisely generates the $(24,12,8)$ code from the described component codes. The role of $C_3$ in each segment provides structural redundancy (triple coverage), with the additional degrees of freedom assigned via $C_2$ and $C_1$.

## 5. Specific Parameter Choices in Construction

Parameter selection in Ji et al. aligns with the standard Golay instantiation:

| Code      | Parameters    | Generator Matrix                             | Notes                                                         |
|-----------|--------------|----------------------------------------------|---------------------------------------------------------------|
| $C_1$     | $(8,7,2)$    | $G^*(8,7) = [I_7\,|\,\mathbf{1}_7]$         | Single-parity-check                                           |
| $C_2$     | $(8,4,4)$    | $G_8$ as from $\operatorname{RM}(1,3)$       | Reed–Muller, four heavy rows                                  |
| $C_2'$    | $(8,4,4)$    | $G_8'$ (column permutation $\pi_3$)          | Symmetric structural redundancy                               |
| $C_3$     | $(8,1,8)$    | $G_{\mathrm{rep}}$ (all-ones)                | Repetition                                                   |

This explicit structure facilitates efficient encoding and algebraic manipulation.

## 6. Integration into Modern PAC-Based Decoding

Building on the cubing construction, Ji et al. [2602.01657] identify a direct connection to the polar generator $G_{24}^p = F_2^{\otimes 3} \otimes F_2^{\otimes 3}$ (a $3 \times 3'$ polar “cube”). They demonstrate that, for suitable sets and pre-transforms,
$$
\left[v_\mathcal{A},\,0_{12}\right]T G_{24}^p = v_\mathcal{A} \hat{G}
$$
where $\mathcal{A} \subset [24]$, $|\mathcal{A}| = 12$, and $T$ is an upper-triangular convolutional transform.

Three distinct $3 \times 3$ polar kernels $F_3^{(i)}$ and pre-transforms $T_i$ give rise to three PAC code representations of the Golay code. This enables parallel decoding: three SCL (successive cancellation list) decoders, each with list size $L$, yield $3L$ codeword candidates, allowing selection of the most likely path. Empirical results show near-ML decoding is attained with $L\approx 8$, and this method obviates ad hoc column permutations or codeword puncturing.

The approach generalizes to parallel decoding of related lattices such as the Leech lattice $\Lambda_{24}$ and its sublattice $H_{24}$.

## 7. Broader Significance and Applications

Forney’s cubing construction, especially as modernized through PAC-based techniques, provides:
- Structural insight into the Golay code’s deep symmetry and triple redundancy
- Algebraic pathways for efficient implementation and algebraic enumeration of codewords
- Foundations for small-list parallel list decoders achieving near-ML performance without manual index manipulation
- Transferability to the construction and efficient decoding of high-dimensional lattices, such as $H_{24}$ and $\Lambda_{24}$

A plausible implication is that these canonical algebraic decompositions may further inform code design and application in multilevel lattice decoders and other domains seeking both algebraic regularity and decoding efficiency [2602.01657].

Source: https://www.emergentmind.com/topics/forney-s-cubing-construction-of-golay-codes