Segmented GRAND: Complexity Reduction through Sub-Pattern Combination

TL;DR

Segmented ORBGRAND introduces a segmentation of the error-pattern search space using syndrome-derived constraints, enabling segment-specific sub-pattern generation and a two-level logistic-weight partitioning to combine these sub-patterns in a near-ML order. This approach dramatically reduces the average number of queries and basic operations compared to ORBGRAND, with additional gains under abandonment and via pre-generated sub-pattern pools. It preserves near-ML performance while offering substantial practical speedups, particularly for high-rate codes, and provides analytic justifications for the logistic-weight ordering approximation to ML order. The method is complemented by hardware-oriented implementation strategies and complexity analyses, illustrating significant decoding-time improvements and viable pathways for hardware realizations. The work demonstrates the potential of syndrome-guided segmentation to achieve efficient, near-ML universal decoding for short, high-rate codes.

Abstract

The ordered-reliability bits (ORB) variant of guessing random additive noise decoding (GRAND), known as ORBGRAND, achieves remarkably low time complexity at high code rates compared to other GRAND variants. However, its computational complexity remains higher than other near-ML universal decoders like ordered-statistics decoding (OSD). To address this, we propose segmented ORBGRAND, which partitions the error pattern search space based on code properties, generates syndrome-consistent sub-patterns (reducing invalid error patterns), and combines them in a near-ML order using sub-weights derived from two-level integer partitions of logistic weight. Numerical results show that segmented ORBGRAND reduces the average number of queries by at least 66\% across all SNRs and cuts basic operations by over an order of magnitude, depending on segmentation and code rate. Further efficiency gains come from leveraging pre-generated shared sub-patterns, reducing average decoding time. Furthermore, with abandonment ($b=10^{5}$ or smaller), segmented ORBGRAND provides a 0.2 dB power gain over ORBGRAND. Additionally, we provide an analytical justification for why the logistic weight-based ordering of error patterns in ORBGRAND closely approximates the ML order and discuss the underlying assumptions of ORBGRAND.

Figures (15)

• Figure 1: The error pattern generation process with pre-evaluation based on two constraints in "constrained GRAND" rowshan-const_GRAND.
• Figure 2: The proposed error pattern generation approach based on two sub-patterns in "segmented GRAND".
• Figure 3: Two-level integer partitioning to generate error patterns for $p$ segments. Note that we have $j\in[1,p]$ and $t,t'$ are the number of parts (odd, even, or arbitrary when we don't have $s_j$ for the corresponding segment such as segment $\mathcal{S}_{j_2}^\prime$ in Example \ref{['ex:h1_subset_h2']}).
• Figure 4: The sub-weights generated based on $\mathbf{s}=[s_1=1\;s_2=0]$ for two-segment based GRAND. For $w_L=1,2,3$, the base $\bf=[1\;0]$ is activated only because the base $\bf=[1\;1]$ has $\underline{w}_L=4$. We have both bases activated for $w_L\geq4$.
• Figure 5: An example of two-level error pattern generation based on sub-patterns when $\mathbf{s}=[s_1=1\;s_2=0]$. Note that $n1$ and $n2$ are the lengths of segments 1 and 2.

Theorems & Definitions (25)

• Definition 1
• Example 1
• Remark 1
• Proposition 1
• proof
• Remark 2
• Definition 2
• Remark 3
• Example 2
• Remark 4