GRAND: Noise Pattern Guessing for Universal Decoding

• GRAND is a universal noise-guessing decoding paradigm that iteratively applies candidate error patterns to recover valid linear codewords using maximum-likelihood principles.
• It employs various algorithmic variants such as hard-decision, soft-input, and ORBGRAND to adapt to different channel conditions and hardware constraints.
• Its design enables parallel, low-latency, and high-throughput implementations, making it a scalable and code-agnostic solution for modern communication systems.

Guessing Random Additive Noise Decoding (GRAND) is a universal paradigm for maximum-likelihood (ML) decoding across a wide range of linear codes and channel conditions. Rather than identifying the transmitted codeword directly, GRAND operates by iteratively constructing and applying candidate noise (error) patterns to the received sequence, seeking the most probable such pattern that, when inverted, yields a valid codeword. This noise-centric, code-agnostic approach enables ML or near-ML decoding for arbitrary linear codes, with variants to accommodate hard and soft input, finite latency, memory constraints, parallel implementation, and advanced finite-length performance tuning.

1. Fundamental Principle of GRAND

In the canonical setting, a codeword $c \in \mathbb{F}_2^n$ is transmitted over a memoryless channel and received as $r = c \oplus e$, where $e$ is an unknown noise (error pattern). The maximum-likelihood decoding rule seeks the codeword $c$ maximizing the conditional probability $P(r|c)$, which—by channel symmetry—reduces to maximizing the likelihood $P(e = r \oplus c)$ over $c \in \mathcal{C}$, where $\mathcal{C}$ is the code's set of valid codewords. Traditional decoding algorithms traverse the codebook or exploit code structure; GRAND inverts this, generating candidate error patterns $e$ ordered by descending likelihood and, for each, checking whether $r \oplus e$ belongs to $\mathcal{C}$. The first such $e$ yielding membership produces the ML codeword. This is achieved by:

1. Constructing a prioritized list of candidate error patterns $e$ (e.g., lowest Hamming weight first for BSC, soft-weighted order for AWGN).
2. For each $e$:
   • Compute $c' = r \oplus e$.
   • Apply the syndrome test with the parity-check matrix $H$ to verify $H c'^{\mathrm{T}} = 0$.
   • Halt upon the first all-zero syndrome; $c'$ is ML (Abbas et al., 2020, Duffy et al., 2018).

This framework naturally supports both hard-decision and soft-input channels, with the candidate ordering metric adapted to the corresponding likelihood calculation.

2. Algorithmic Variants and Ordering Metrics

Several prominent GRAND variants address code structure, soft information, complexity, and hardware implementation constraints:

• Hard-input GRAND and GRANDAB: For binary symmetric or hard-decision channels, error patterns are generated by ascending Hamming weight. The abandonment variant GRANDAB(AB=$t$) restricts the search to patterns of weight $\leq t$, yielding a fixed maximum number of queries at the cost of only approximate ML performance if the true error weight is higher (Abbas et al., 2020).
• Soft-input and Reliability-Ordered GRAND: For AWGN or general noisy channels, the ordering utilizes soft information. Under BPSK/AWGN, LLRs $\lambda_i = 2y_i/\sigma^2$ are computed for each received bit $y_i$. Patterns are ranked by the soft-weight metric $\sum_{i=1}^n |\lambda_i| e_i$, yielding true ML order. However, this is exponentially complex due to the need to sort all $2^n$ patterns by real-valued weight (Abbas et al., 2021).
• ORBGRAND (Ordered Reliability Bits GRAND): Implements a hardware-efficient, parallelizable ordering by replacing LLR values with their rank among all received reliabilities. Candidate patterns are constructed efficiently via integer partitions of a "logistic weight" $\sum_{k=1}^n k \cdot e_k$, trying those with lower-weight on less reliable bits first. Only $\lceil \log_2 n \rceil$ bits per block are required for the rank order, dramatically simplifying dataflow and parallelization (Duffy, 2020, Duffy et al., 2022, Condo, 2021).
• List-GRAND: Augments the search with a small candidate list, reranking found codewords by actual likelihood to close the residual performance gap between ORBGRAND and SGRAND, matching true ML decoding with moderate (factor $<2$) complexity overhead (Abbas et al., 2021).

3. Insights into Complexity, Universality, and Capacity

GRAND's key theoretical property is that, when error patterns are ranked in the correct likelihood order, the first codeword found is ML. For memoryless channels, this ensures capacity-achieving error correction for random codes at all rates up to capacity. The average number of queries follows the position of the true error pattern in the likelihood-ranked list, which for random codes is geometrically distributed with mean $2^{n-k}$, shrinking rapidly as code redundancy increases or SNR improves (Duffy et al., 2018, Abbas et al., 2020).

The universality of GRAND stems from its independence of code structure—any linear code can be decoded by loading its parity-check matrix $H$. This universality applies equally to random linear codes, CRC-augmented codes, BCH, and polar codes, with equivalent performance demonstrated empirically (Abbas et al., 2021, Duffy, 2020).

4. Hardware Architectures and VLSI Implementations

GRAND and especially ORBGRAND are amenable to highly parallel, pipelined architectures suitable for VLSI implementation. The core approach exploits:

• Syndrome precomputation: Bitwise syndromes $s_i=H \cdot 1_i^\mathrm{T}$ for all positions $i$ can be prestored, enabling rapid computation of syndromes for all patterns of weight up to 3 by parallel XORs of $s_0=Hr^\mathrm{T}$ with these columns.
• Pipeline parallelism: Specialized controllers sequence through combinations of positions to check all weight-$w$ patterns in $O(n^w)$ cycles but with high concurrency, yielding average time much smaller compared to total queries.
• Early stopping: The search halts at the first zero-syndrome detection, exploiting the probabilistic concentration of low-weight errors at moderate to high SNR, so average latency is typically only a small fraction of worst-case (Abbas et al., 2020, Abbas et al., 2021).

Table: Performance Comparison (n=128, AB=3, TSMC 65 nm, SNR=10 dB) (Abbas et al., 2020, Abbas et al., 2021) | Decoder Type | Area (mm²) | Avg Throughput (Gbps) | Avg Latency (cycles) | Code Agnostic | |--------------|------------|-----------------------|----------------------|---------------| | GRANDAB | 0.25 | 32–64 | ~1.1 | Yes | | ORBGRAND | 1.82 | 42.5 | 2.47 | Yes |

Throughput scales with code length and code rate; longer codes benefit from even greater parallelization efficiency. GRANDAB and ORBGRAND achieve $>$30–64 Gbps for $n=128$, $k/n>0.75$ at SNR = 10 dB.

5. Performance and Comparison to Classical Decoders

In terms of raw decoding quality (e.g., achieved BLER at target SNR), GRAND and its variants are competitive with or superior to dedicated decoders (e.g., Berlekamp–Massey for BCH, CA-SCL for CRC-polar, Chase for generic codes):

• For the $(79,64)$ BCH code, GRANDAB matches the tailored BCH decoder in decoding performance, with higher throughput at high SNR (Abbas et al., 2020).
• ORBGRAND achieves up to 0.5 dB gain compared to CA-SCL(16) for CA-polar(128,106), and 0.5–1 dB over BM for BCH codes of similar length (Duffy, 2020).
• GRAND decoders are code- and rate-agnostic: any linear code can be loaded by updating $H$, allowing a single VLSI implementation to serve multiple codes and configurations without code-specific logic (Abbas et al., 2021, Condo, 2021, Abbas et al., 2020).
• The average query count—and hence latency—drops precipitously at higher SNR, with worst-case latency only a small multiple of the per-codeword syndrome checks when early stopping and parallel architectures are exploited.

6. Tradeoffs, Limitations, and Future Directions

While pure GRAND and its variants offer strong universality and performance, certain tradeoffs exist:

• Area/complexity: Hardware-efficient variants (ORBGRAND) trade some performance against soft-GRAND (SGRAND) ML decoding, but with throughput, memory, and implementation costs several orders of magnitude lower (Abbas et al., 2021).
• Worst-case latency: Without abandonment, worst-case query counts remain exponential, necessitating abort thresholds (GRANDAB). In practice, high SNR regimes render this unlikely to trigger.
• Soft/Hard tradeoff: The gain from soft information depends on channel conditions. Fine-tuning the error-pattern ordering by incorporating small amounts of exact soft values (e.g., specific LLRs) can narrow the gap to ML with negligible added cost (Wan et al., 11 Jul 2025).
• Extension to non-binary and fading channels: Ongoing work generalizes GRAND to non-binary alphabets, symbol-level error pattern generation, and channel state-aware ordering for fading and high-order modulations (Chatzigeorgiou et al., 2022, Sarieddeen et al., 2022, Abbas et al., 2022).

Advances in architectural parallelism, syndrome precomputation, and pattern generation further reduce latency and complexity, making GRAND an attractive basis for high-throughput, low-latency, code-agnostic decoders in modern communication systems.

7. Universality, Parallelism, and Application Scope

GRAND's universality and code-agnosticism result from its abstraction of the channel noise effect and exploitation of the parity-check membership criterion alone. This enables:

• Single-silicon realization: Any code length, rate, or type (BCH, polar, CRC, or random code) can be supported by a single hardware core; only the $H$ matrix need be updated.
• Parallelization: Algebraic sharing and symmetry in the code structure permit highly parallel syndrome computation, dramatically reducing effective average decoding time for large codes (Abbas et al., 2020, Abbas et al., 2021).
• Throughput scaling: As code length increases, parallel testing over combinations of error patterns yields throughput scaling nearly linearly with $n$, enabling Gbps-level rates without code-specific architectural redesign (Abbas et al., 2020).
• Early stopping and complexity control: The average number of queries until decoding at moderate/high SNR is a small fraction of the worst-case, and abandonment strategies (GRANDAB, fixed max queries) bound latency deterministically.

These features collectively position GRAND as a foundational universal decoder architecture for future ultra-reliable low-latency communication systems, adaptable to evolving codes and standards with minimal hardware changes (Abbas et al., 2020).