[Paper Review] Segmented GRAND: Complexity Reduction through Sub-Pattern Combination

Mohammad Rowshan, Jinhong Yuan|arXiv (Cornell University)|May 24, 2023

Advanced Wireless Communication Techniques4 citations

TL;DR

This paper proposes segmented ORBGRAND, a near-maximum-likelihood decoding scheme that reduces complexity by dividing codewords into segments based on parity constraints, generating sub-patterns per segment, and combining them via two-level integer partitions in near-ML order. The method reduces average queries by up to threefold and improves BLER performance with abandonment, especially at low SNR and low code rates.

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.

Motivation & Objective

• Address the high decoding complexity of GRAND at low SNR and low code rates, where conventional ORBGRAND and GRAND struggle due to excessive invalid error pattern queries.
• Reduce the number of invalid error patterns generated during decoding by leveraging parity constraints to restrict search space per segment.
• Improve error correction performance and reduce average query count by combining sub-patterns in a near-ML order using two-level integer partitions.
• Enable practical implementation of near-ML decoding for short-block-length codes by significantly lowering computational load without sacrificing performance.

Proposed method

• Divide the codeword into segments based on the structure of the parity-check matrix, using row operations to extract independent parity constraints for each segment.
• Generate sub-patterns for each segment that are consistent with the syndrome, ensuring only valid error patterns are considered within each segment.
• Use two-level integer partitions of logistic weight to order sub-pattern combinations in a near-ML sequence, prioritizing the most likely error pattern combinations.
• Combine sub-patterns from different segments in a way that maintains likelihood ordering while reducing the total number of candidate patterns to test.
• Introduce an abandonment threshold to terminate decoding early if a valid codeword is not found within a predefined number of queries, improving efficiency at the cost of slight BLER degradation.
• Leverage the reliability of bits and the structure of the code to guide segmentation and sub-pattern generation, minimizing the number of inconsistent error patterns.

Fig. 1: The error pattern generation process with pre-evaluation in “constrained GRAND” [ 28 ] for two constraints.

Experimental results

Research questions

• RQ1 Can segmenting the codeword based on parity constraints reduce the number of invalid error patterns generated during GRAND decoding?
• RQ2 Does combining sub-patterns from segmented codewords in a two-level integer partitioned order achieve near-ML performance with lower complexity?
• RQ3 To what extent does the proposed segmented ORBGRAND reduce the average number of queries compared to conventional ORBGRAND across different SNR regimes?
• RQ4 How does the inclusion of an abandonment threshold affect the trade-off between decoding complexity and block error rate (BLER)?
• RQ5 Can segmented ORBGRAND outperform traditional ML decoding schemes like OSD and Chase-II in terms of complexity and BLER for short-block-length codes?

Key findings

• Segmented ORBGRAND reduces the average number of queries by up to threefold compared to conventional ORBGRAND for eBCH(128,106), especially at high SNR.
• With an abandonment threshold of $10^5$, the average queries for eBCH(128,106) drop from 460.7 (NoC) to 208.9 (2C), representing a 55% reduction.
• For PAC(64,44), the average queries are reduced from 95.1 (NoC) to 49.0 (3C), a 48.4% reduction, demonstrating consistent performance gains.
• The BLER performance of segmented ORBGRAND remains nearly identical to ORBGRAND, while achieving significantly lower complexity.
• The method improves error correction performance when combined with abandonment, as the reduced search space increases the likelihood of finding a valid codeword within the threshold.
• Segmented ORBGRAND outperforms OSD(2) in complexity at high SNR and matches or exceeds Chase-II(3) in BLER with far fewer queries, demonstrating superior efficiency.

Fig. 2: The proposed error pattern generation approach based on sub-patterns in “segmented GRAND” for two segments.