Polar Orbit Decoding (POD)

• Polar Orbit Decoding is a universal decoding framework that embeds any binary linear block code into a polar subcode using dynamic-frozen constraints.
• It leverages automorphism groups to generate permutation orbits, enabling parallel soft-decoding streams that approach near-maximum-likelihood performance.
• The framework reduces hardware complexity by unifying diverse BLBCs under a single polar decoder architecture, balancing latency and error-rate tradeoffs.

Polar Orbit Decoding (POD) is a universal, parallel soft-decoding framework for binary linear block codes (BLBCs), designed to enable near-maximum-likelihood (ML) performance with low latency and universal hardware compatibility. By exploiting code automorphisms to generate distinct permutation orbits and embedding any BLBC into the polar code framework with dynamic-frozen constraints, POD unifies the decoding process for diverse code families within a single decoder architecture (Li et al., 16 Jan 2026).

1. Universal Representation of Binary Linear Block Codes

A binary linear block code $C$ over $\mathbb{F}_2$ of length $n$ and dimension $k$ is described by a $k \times n$ generator matrix $G$:

$C = \{c = mG \mid m \in \mathbb{F}_2^{k} \}.$

Traditional code families (BCH, Golay, Reed–Muller, LDPC) offer tradeoffs between minimum distance, complexity, and asymptotics. No single family is optimal across all metrics; consequently, standards such as 5G implement multi-code architectures, demanding multiple decoder types per device and multiplying hardware complexity.

Universal polar decoding circumvents this by embedding any BLBC into a polar code—specifically, as a polar subcode with “dynamic frozen” bits. This process uses:

• A length-$n$ polar generator $G_n = B_n F^{\otimes m}$, with $n=2^m$, $F = \begin{bmatrix}1 & 0\1 & 1\end{bmatrix}$, and $B_n$ as the bit-reversal permutation.
• A permutation matrix $P\in \operatorname{Sym}(n)$.
• The code is mapped via $GP^{-1}G_n$, then row-reduced to form an upper-trapezoidal matrix $M$ of dynamic frozen constraints:

$\{ c = mMG_n \mid m \in \mathbb{F}_2^k \}$

This expresses the original BLBC as a polar subcode; constraints in $M$ are enforced during polar-style decoding (successive-cancellation [SC], or SC-list [SCL]).

Significance: Universal embedding permits one hardware decoder to process any BLBC, conditional on efficient and flexible polar decoding.

2. Automorphism Groups and Permutation Orbits

The automorphism group $H$ of a code $C$ with generator $G$ is:

$$H = \{ h \in \operatorname{Sym}(n) \mid \exists E\in GL_k(\mathbb{F}_2): EG = Gh^{-1} \}$$

This comprises all coordinate permutations mapping the code onto itself—equivalently, $h\in H$ if permuting $G$’s columns via $h$ yields a matrix with the same row space.

Invariant Dynamic Frozen Sets: For any polar embedding permutation $P$, every $h\in H$ gives rise to $P' = P h$ with the same dynamic frozen matrix $M$. That is, for all $h \in H$,

$GP'^{-1} G_n = G h^{-1} P^{-1} G_n$

produces identical polar-constraint matrices after RREF, so the subcode constraints are invariant under automorphism-induced permutations.

Automorphism Orbits: Fixing $P$, the associated orbit is

$O_P = \{ P h \mid h \in H \}$

Each $P h$ defines a distinct embedding trajectory yet preserves the dynamic frozen constraints. Decoding the received word $y$ under every element in the orbit provides multiple diverse soft-decoding perspectives, all aligned to the same polar subcode.

This invariance eliminates the need for per-permutation adaptation of the frozen set logic, streamlining hardware implementation.

3. Parallel Decoding Algorithm and Workflow

POD operates by decoding in parallel over $M$ elements of the automorphism orbit $\{P h_1,\ldots,P h_M\}$. The procedural workflow is:

1. Orbit Enumeration: Precompute $M$ distinct automorphisms $h_i\in H$ by subgroup enumeration.
2. Parallel Decoding:
   • For each $i = 1,\ldots,M$, permute the channel log-likelihood ratio (LLR) vector $y$ by $(P h_i)^{-1}$, producing $y^{(i)}$.
   • Input $y^{(i)}$ into a polar-style decoder (SC, SCL of list-size $L$, or related dynamic-frozen bit engine).
   • Collect candidate paths $(\hat{m}_\ell^{(i)}, PM_\ell^{(i)})$ for $\ell=1,\ldots,L$.
3. Candidate Aggregation: Gather all $M\times L$ candidate paths, invert each permutation, and apply a combiner (minimum path metric or BLBC parity check).
4. Output Selection: Select the valid candidate with optimal path metric.

Pseudocode Outline:

def POD(y, P, H_list, L): candidates = [] for i in parallel(range(M)): y_i = permute(y, (P * h_i)^-1) cand_i = PolarListDecode(y_i, M, L) candidates.extend(cand_i) valid_candidates = [] for (m_tilde, PM) in candidates: c_tilde = m_tilde @ M @ G_n c_hat = PermuteBack(c_tilde, P * h_i) if ValidCodeword_H(c_hat): valid_candidates.append((m_hat, PM)) return argmin(valid_candidates, key=lambda x: x[1])

Each PolarListDecode maintains SC path metrics and prunes to the top $L$ survivors per bit index. The frozen-set logic ($M$) remains identical for all decoders.

The effective list size is $M\times L$. Varying $M$ yields control over the tradeoff between latency and performance.

4. Automorphism Orbit Construction: BSGS and Schreier–Sims Methodology

Automorphism groups for BLBCs can be vast (e.g., extended BCH: $O(2^m(m2^m-1))$; Golay $M_{24}$: $\sim 2.4\times 10^8$), necessitating efficient orbit enumeration. POD adopts a base and strong generating set (BSGS) representation via the Schreier–Sims algorithm:

• Base Selection: Choose a sequence of points $\beta = (\beta_1,\ldots,\beta_r)$ in $\{1,\ldots,n\}$.
• Transversal and Generator Refinement: Iteratively refine transversal sets and Schreier generators, maintaining stabilizer chains $$H=H^{(0)} \geq H^{(1)} \geq \ldots \geq H^{(r)} = \{e\}$$. Schreier’s Lemma extracts strong generators for $H^{(i)}$.
• Complexity: BSGS construction is $O(n^5 + n^2 |S|)$ for a generating set $S$ of size $|S|$; for algebraic codes, this remains polynomial in $n$.

With BSGS precomputed, enumeration or random sampling of $M$ orbit elements costs $O(Mr)$ backend operations, negligible for hardware accelerators.

5. Core Formulas and Computational Tradeoffs

The polar transform and codeword mapping utilize:

• Polar Generator:

$$F = \begin{bmatrix}1 & 0 \ 1 & 1\end{bmatrix},\quad G_n = B_n F^{\otimes m},\quad n=2^m$$

• Message and Constraint Application:

$$u = m M \in \mathbb{F}_2^n,\quad c = u G_n \in \mathbb{F}_2^n$$

Within SCL decoding, at each bit index $j$:

• Log-likelihood ratio update:

$$L_j = \log \frac{P(u_j = 0 \mid y, \hat{u}_{<j})}{P(u_j = 1 \mid y, \hat{u}_{<j})}$$

• Path metric update:

$$PM \leftarrow PM + \log\left(1 + e^{-(-1)^{\hat{u}_j} L_j}\right)$$

Latency, list-size, and error-rate are characterized by:

• SC latency: $T_{SC}(n)$
• SCL sorting step: $T_{sort}(L, n)$
• SCL decoding: $T_{SCL}(n, L) \approx T_{SC}(n) + n\,T_{sort}(L)$
• POD with $M$ parallel SC streams: per-stream latency $\approx T_{SC}(n)$, plus $O(ML)$ for combining. Effective list size $M L$ yields performance between $SCL_L$ and $SCL_{ML}$.

6. Performance and Simulation Analysis

Simulations employ additive white Gaussian noise (AWGN) channels, binary phase-shift keying (BPSK), and BLBC-native parity checks for candidate screening. Results span several BLBCs:

Code	POD Configuration	ML Performance Approximation	Latency Profile
(16,7) eBCH	POD$_{16}$–SC	Matches SCL$_8$/ML at high SNR	$\approx T_{SC}$
(64,16) eBCH	POD$_8$–SC	Collides with SCL$_{64}$/ML	SC-per-stream
(64,36) eBCH	POD$_4$–SC	Halves error versus SC, near SCL$_{64}$	SC-per-stream
(24,12) Golay	POD$_4$–SC	$>$1 dB gain over SC, approaches ML	SC-per-stream

Increasing $M$ interpolates error performance between SC and ML with commensurate decreases in decoding latency. Using SCL as the internal decoder (e.g., POD$_2$–SCL$_2$) enables further error-rate improvements (e.g., outperforming SCL$_4$).

This suggests that parallelism via orbit decoding provides a scalable, hardware-efficient route to near-ML performance with controllable tradeoffs.

7. Hardware Implementation and Complexity Considerations

POD hardware instantiates a single polar decoder core ($M$ times in parallel). Each core maintains identical frozen-set logic (matrix $M$); no duplicated constraint computation occurs. BSGS representation for the automorphism group $H$ is stored once, with each $h_i$ retrieved via $O(r)$ pointer-chasing operations.

The final candidate combine step is a modest comparison tree with BLBC code validity checks. The hardware complexity thus scales with the parallel stream count $M$, trading increased decoder cores for reduced wall-clock latency. The universal decoder core is portable across BLBCs given appropriate $M$ and $P$ parameters.

A plausible implication is that universal, parallel polar decoding hardware based on POD may standardize and consolidate BLBC decoder design in future communication systems, reducing the need for heterogeneous multi-code decoder architectures.

Summary

Polar Orbit Decoding employs the automorphism group of any BLBC to produce multiple equivalent polar subcode embeddings, enabling universal, parallel soft decoding. These orbit-induced embeddings facilitate parallel SC or SCL decoding, yielding near-ML performance at SC-level latency and with hardware universality across BLBC classes (Li et al., 16 Jan 2026).