Table-Lookup-Based Decoding

• Table-Lookup-Based Decoding is a method that replaces online arithmetic with precomputed mappings over finite states for faster, deterministic decoding.
• It is applied in constrained sequence codes, polar/LDPC decoders, range coding, and quantum error correction to streamline decision processes.
• The approach involves trade-offs between reduced computational complexity and increased memory overhead, necessitating co-design for optimal performance.

Table-lookup-based decoding denotes a family of decoding strategies in which a decoder replaces online arithmetic, search, or exhaustive matching with direct access to a precomputed mapping from a finite input state to a symbol, message, reliability value, or correction action. The paradigm appears in constrained sequence codes, where the decoder compares a received sequence against a finite set of valid codewords (Cao et al., 2018); in finite-alphabet polar and LDPC decoders, where quantized messages are updated through mutual-information-oriented lookup tables (Shah et al., 2024); in entropy coders, where the current internal code value is mapped directly to a symbol index (Strutz et al., 3 Jan 2026); and in near-term quantum error correction, where a history of detection events indexes a precomputed correction table (Das et al., 2021). This breadth suggests that table lookup is best understood as an implementation pattern for finite-state or quantized decoding rather than as a single algorithm.

1. General structure and formal viewpoint

A table-lookup-based decoder is applicable when the decoder state can be discretized into a finite alphabet, a finite set of valid sequences, or a finite set of interval indices. In that setting, the decoder can precompute the mapping from input state to output decision and perform decoding by array access or direct table matching rather than by recomputing the underlying rule online. Across the literature, the looked-up object may be a codeword, a symbol index, an integer-valued reliability message, a bit log-likelihood ratio (LLR), or a correction assignment (Cao et al., 2018).

Setting	Lookup key	Table output
Constrained sequence codes	Received noisy sequence	Valid constrained sequence or message
Finite-alphabet polar / LDPC decoding	Quantized messages	Next integer message or translated LLR
Range coding	Current code value $c$	Symbol index $i=t[c]$
FTN soft-output detection	Detector output $x_n$	Bit LLR $\lambda_n^m$
Surface-code QEC	History of detection events	Error assignment and update bits
Low-bit LLM decoding	Packed weight index or ternary pattern	Precomputed partial sum

The formal role of the table depends on the decoder. In constrained sequence decoding, the reference decision rule is maximum a posteriori probability (MAP) decoding,

$$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$

which, under equal priors, reduces to

$$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$

A table-lookup decoder implements this over the finite constrained set $\mathcal{C}$ by explicit matching rather than by deriving the score online (Cao et al., 2018). In range coding, the same principle appears as interval classification: each code value $c$ belongs to exactly one cumulative-count interval, so the decoder can replace interval search by the direct map $i \gets t[c]$ (Strutz et al., 3 Jan 2026).

The same abstraction extends to quantized iterative decoders. In finite-alphabet polar decoding, the decoder passes integer messages

$$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$

and each node uses a decoding table whose input is a tuple of quantized messages and whose output is the next integer symbol in $i=t[c]$0 (Shah et al., 2024). In information-bottleneck designs, the lookup table is itself the deterministic mapping $i=t[c]$1 produced by maximizing $i=t[c]$2 subject to a constrained output alphabet (Balatsoukas-Stimming et al., 2015).

2. Constrained sequence codes and explicit codebook lookup

Constrained sequence codes are codes whose output sequences satisfy constraints imposed by the physical channel or storage medium. The motivating examples are sequences that avoid patterns harmful to the channel, so the encoder emits only members of a finite constrained set. Because the codebook is discrete and finite, traditional decoding is naturally implemented by table lookup: the received sequence is compared against a precomputed list of all valid codewords, and the decoder selects the most likely one (Cao et al., 2018).

In this setting, table lookup has two explicit weaknesses. First, traditional table-look-up decoding is described as “prone to errors that occur during transmission.” When noise corrupts the transmitted constrained sequence, exact table matching can fail or become unreliable because the received sequence may no longer coincide with a valid table entry. Second, as block length grows, the number of valid constrained sequences can become very large, so storing the table becomes costly, searching it becomes computationally expensive, and implementing capacity-achieving fixed-length codes becomes impractical because the complexity is “prohibitively high” (Cao et al., 2018).

The constrained-sequence literature therefore uses table-lookup-based decoding both as the historical baseline and as the object of replacement. In “Deep Learning-Based Decoding for Constrained Sequence Codes” (Cao et al., 2018), multiple layer perception (MLP) networks and convolutional neural networks (CNNs) are trained to learn the decoder function from examples instead of consulting the explicit table. The reported result is low bit error rates close to MAP decoding, improved system throughput, and a practical route to capacity-achieving fixed-length codes whose table-look-up decoding would otherwise be prohibitively complex. Within that argument, table lookup is not rejected as conceptually incorrect; rather, it is treated as accurate for small finite codebooks but brittle under channel noise and poorly scalable as the constrained set grows.

3. Finite-alphabet message-passing decoders for polar and LDPC codes

A major branch of table-lookup-based decoding replaces real-valued belief-propagation or successive-cancellation updates with operations on small discrete alphabets. In “Finite Alphabet Fast List Decoders for Polar Codes” (Shah et al., 2024), the conventional log-likelihood ratio recursion is replaced by lookup operations on low-resolution integer messages drawn from

$i=t[c]$3

The symbols are ordered by reliability and constrained by odd symmetry,

$i=t[c]$4

The lookup tables are designed offline by the information bottleneck method, which maximizes $i=t[c]$5 under the alphabet-size constraint and produces both the decoding table and a translation table for recovering the LLR

$i=t[c]$6

Fast decoding schedules then collapse subtrees into $i=t[c]$7, $i=t[c]$8, $i=t[c]$9, and $x_n$0 nodes without redesigning the tables. For $x_n$1, the number of unique decoding tables can drop from $x_n$2 in conventional LUT-SCL to as few as $x_n$3 for IB FSCL and $x_n$4 for MSIB FSCL, with up to $x_n$5 fewer unique lookup tables and negligible loss in error correction performance (Shah et al., 2024).

The same theme appears in implementation-oriented polar decoders. “Implementation-Efficient Finite Alphabet Decoding of Polar Codes” (Mohr et al., 2023) keeps the finite-alphabet viewpoint but replaces the upper-branch lookup by a min-sum rule and implements the lower-branch mapping in a computational domain. The lower branch is quantized by

$x_n$6

so clipping and bit-shifting substitute for a large explicit lower-branch table. For $x_n$7, the pure lookup-table lower-branch solution needs more than $x_n$8 the memory bits of the proposed method, while the performance loss relative to floating-point LLR decoding is about $x_n$9 dB under SC and only $\lambda_n^m$0–$\lambda_n^m$1 dB relative to IB-IB under CRC-aided SCL, depending on code rate (Mohr et al., 2023). This is a reminder that table-lookup-based decoding is often most effective when the table itself is co-designed with arithmetic simplifications.

In LDPC decoding, the same replacement can occur at the variable-node level. “A Fully-Unrolled LDPC Decoder Based on Quantized Message Passing” (Balatsoukas-Stimming et al., 2015) replaces the standard min-sum variable-node update by a generic lookup-table mapping chosen to maximize the mutual information between outgoing messages and codeword bits,

$\lambda_n^m$2

The check node remains in standard min-sum form, but the messages are finite-alphabet labels. The reported design uses $\lambda_n^m$3 bits for channel LLRs and $\lambda_n^m$4 bits for internal messages, yet achieves FER performance very close to floating-point min-sum. In fully unrolled hardware, the LUT-based architecture reaches $\lambda_n^m$5 Gbps throughput and $\lambda_n^m$6 Gbps/mm$\lambda_n^m$7 area efficiency, compared with $\lambda_n^m$8 Gbps and $\lambda_n^m$9 Gbps/mm$$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$0 for the adder-based min-sum reference (Balatsoukas-Stimming et al., 2015).

The non-binary extension is more involved because the tables must absorb finite-field arithmetic. “Decoding of Non-Binary LDPC Codes Using the Information Bottleneck Method” (Stark et al., 2018) uses lookup tables for edge-weight multiplication, GF convolution, and variable-node combination, with internal messages represented by small integer indices rather than probability vectors. In the reported GF$$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$1 experiment, the proposed decoder is about $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$2 dB worse than sum-product, outperforms log-max by about $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$3 dB, and reduces online complexity to $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$4 with $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$5-bit internal messages, at the cost of $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$6 kB of lookup-table memory per iteration (Stark et al., 2018).

A related but distinct idea appears in “Adaptive Decoding of LDPC Codes with Binary Messages” (0902.3287). There the decoder passes binary vector messages of length $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$7, and the variable node uses pre-computed lookup tables to map vector weight to extrinsic reliability. Both the lookup table and the number of sub-iterations are adapted online using the syndrome information

$$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$8

For a $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{x}\mid \mathbf{y}),$$9 LDPC code of length $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$0, BERs of $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$1 are reported with about $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$2 average sub-iterations, showing that lookup tables can be state-dependent rather than fixed (0902.3287).

4. Soft-output detection and entropy decoding

Table lookup is also used when the decoder’s main burden is not message passing over a code graph but conversion from a finite detector state to a soft reliability value or from an interval state to a source symbol.

In “Low Complexity Lookup Table Aided Soft Output Semidefinite Relaxation based Faster-than-Nyquist Signaling Detector” (Cicek et al., 2020), the detection front end is a semidefinite-relaxation approximation to the FTN maximum-likelihood sequence estimate, and the lookup table does not store sequence metrics for all transmit vectors. Instead, it stores bit LLRs as a function of the detector output $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$3,

$$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$4

The table is built offline, per SNR point, by generating detector outputs, binning them, estimating conditional PDFs, and then storing the resulting LLRs. At runtime, soft-output generation is reduced to index computation and retrieval. The detector therefore inherits the polynomial-time complexity of SDR, roughly $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$5, while the LUT adds negligible overhead. In the reported experiments, the uncoded detector is about $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$6 dB behind BCJR at BER $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$7, and the coded detector is about $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$8 dB away from BCJR with a fixed LUT and about $$\hat{\mathbf{x}} = \arg\max_{\mathbf{x}\in\mathcal{C}} P(\mathbf{y}\mid \mathbf{x}).$$9 dB away with SNR-specific LUTs (Cicek et al., 2020).

In entropy coding, the role of the table is different but closely related. “Range-Coder with fast Adaptation and Table-Based Decoding” (Strutz et al., 3 Jan 2026) replaces the conventional search over cumulative-count intervals with direct symbol lookup. If cumulative counts satisfy

$\mathcal{C}$0

then the decoder ordinarily determines the symbol by finding the interval containing the current code value $\mathcal{C}$1. The table-based decoder precomputes

$\mathcal{C}$2

so symbol identification becomes $\mathcal{C}$3. The decoder state then updates by

$\mathcal{C}$4

To avoid division, the paper chooses a power-of-two total count $\mathcal{C}$5, so $\mathcal{C}$6 becomes $\mathcal{C}$7. The main complication is adaptation: in adaptive mode, naïve table rebuilding would be too expensive. The proposed ring-buffer method keeps the total count fixed after an initial fill phase and updates only the affected boundaries. In static mode, table-based decoding plus shift-based core operations reduce coding time by about $\mathcal{C}$8; in adaptive mode, the proposed method is faster than alternatives for alphabets from about $\mathcal{C}$9 to $c$0 different symbol when comparing overall encoder+decoder time (Strutz et al., 3 Jan 2026).

These two cases illustrate a recurring distinction. In FTN detection, the table approximates a soft metric that would otherwise require an expensive likelihood computation. In range coding, the table removes a search step exactly. This suggests two broad classes of table-lookup-based decoding: metric approximation and decision indexing.

5. Real-time implementations, unrolling, and quantum error correction

Because a table access is deterministic and local, table-lookup-based decoding is especially attractive in hardware that prioritizes bounded latency. The literature also shows, however, that replacing arithmetic with LUTs does not automatically improve area or throughput.

“Unrolled and Pipelined Decoders based on Look-Up Tables for Polar Codes” (Giard et al., 2023) makes this point explicitly. The paper compares three LUT-based variants—IB, MS-IB, and re-MS-IB—against a regular unrolled fixed-point decoder for a systematic $c$1 polar code. All versions achieve information throughput a little under $c$2 Gbps in 28 nm FD-SOI technology clocked in the vicinity of $c$3 GHz to $c$4 GHz, but the hardware consequences differ sharply. The direct IB and MS-IB variants are larger than the fixed-point baseline, whereas the re-MS-IB variant, which relabels the message alphabet to simplify the $c$5-block realization, reduces area by $c$6, increases throughput by $c$7, and improves area efficiency by $c$8 while retaining comparable error-correction performance (Giard et al., 2023). A common misconception is therefore that “LUT-based” is inherently smaller; the evidence is more conditional.

In near-term quantum error correction, deterministic latency is a primary requirement. “LILLIPUT: A Lightweight Low-Latency Lookup-Table Based Decoder for Near-term Quantum Error Correction” (Das et al., 2021) converts consecutive syndrome rounds into detection events, concatenates a sliding window of $c$9 rounds into a LUT address, and retrieves the error assignment for the oldest layer together with update bits. The decoder is fully pipelined and produces a correction after $i \gets t[c]$0 clock cycles. The reported latencies are $i \gets t[c]$1 ns for $i \gets t[c]$2, $i \gets t[c]$3 ns for $i \gets t[c]$4, $i \gets t[c]$5 ns for $i \gets t[c]$6, $i \gets t[c]$7 ns for $i \gets t[c]$8, and $i \gets t[c]$9 ns for $$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$0. The baseline design uses $$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$1–$$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$2 logic for the smaller configurations, but the memory requirement grows rapidly: the total memory reaches $$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$3 MB for $$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$4. Compressed LUTs (CLUTs) exploit the nonuniform likelihood of error events and reduce that $$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$5 MB to $$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$6 MB, a $$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$7 reduction, with no observable loss in decoding accuracy (Das et al., 2021).

At the fault-tolerant circuit level, “Space-time optimized table lookup” (Häner et al., 2022) studies the quantum table-lookup primitive

$$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$8

under lattice-surgery surface-code constraints. The work is not itself a decoder, but it is directly relevant to lookup-heavy decoding oracles. The paper derives explicit non-Clifford cost formulas such as

$$\mathcal{T}=\{0,1,\dots,|\mathcal{T}|-1\}, \qquad |\mathcal{T}|=2^w,$$9

for uncontrolled lookup, together with zipper-based space-time tradeoffs. This shows that even in quantum settings the lookup operation is treated as a reusable decoding backend whose central tension is the tradeoff between depth, qubit count, and locality (Häner et al., 2022).

6. Autoregressive LLM decoding and recurring system-level trade-offs

Recent low-bit LLM systems use “decoding” in the autoregressive-inference sense, and table lookup has reappeared there as a way to replace dequantization and low-bit multiply-accumulate with precomputed table access. The mapping is conceptually the same as in classical decoders: a small discrete pattern is turned into an address, and the table returns the precomputed contribution to the next-state computation.

In “Vec-LUT: Vector Table Lookup for Parallel Ultra-Low-Bit LLM Inference on Edge Devices” (Li et al., 6 Dec 2025), scalar LUT inference is identified as a bandwidth bottleneck during parallel inference. The basic scalar formulation is

$i=t[c]$00

but with many parallel tokens this requires loading $i=t[c]$01 tables and performing $i=t[c]$02 separate lookup passes. Vec-LUT instead constructs a unified table across tokens and performs a single $i=t[c]$03 lookup per weight index,

$i=t[c]$04

The paper reports that scalar LUT access often uses $i=t[c]$05 of memory bandwidth, that lookup accounts for around $i=t[c]$06 of mpGeMM latency in T-MAC profiling, and that Vec-LUT reduces lookup cost to below $i=t[c]$07. End-to-end prefilling improves by up to $i=t[c]$08, parallel decoding by up to $i=t[c]$09, and continuous batching reaches $i=t[c]$10 tokens/s on AWS Graviton 3 (Li et al., 6 Dec 2025).

“T-MAN: Enabling End-to-End Low-Bit LLM Inference on NPUs via Unified Table Lookup” (Wei et al., 14 Nov 2025) applies the same principle to mobile NPUs. The central observation is that low-bit quantization makes the table small enough to encode the target computation, so decoding can be mapped to vector-core lookup instructions rather than to dequantization followed by GEMV. The work combines fused two-level table-based dequantization with concurrency-hierarchy-guided tiling and reports $i=t[c]$11 speedup for decoding, $i=t[c]$12 for prefill, and $i=t[c]$13 energy savings compared with baseline NPU methods (Wei et al., 14 Nov 2025).

On edge FPGAs, “TeLLMe v2: An Efficient End-to-End Ternary LLM Prefill and Decode Accelerator with Table-Lookup Matmul on Edge FPGAs” (Qiao et al., 3 Oct 2025) uses table-lookup-based ternary matrix multiplication (TLMM) with grouped activations and online precomputation. The ternary weight group size $i=t[c]$14 induces $i=t[c]$15 possible combinations, and the engine uses the group index to address a table of partial sums. In the decoding path, the system streams $i=t[c]$16 and $i=t[c]$17 from DDR, keeps intermediate attention scores on chip, and reports up to $i=t[c]$18 tokens/s at $i=t[c]$19 W, with $i=t[c]$20–$i=t[c]$21 s time-to-first-token for $i=t[c]$22–$i=t[c]$23-token prompts under a $i=t[c]$24 W power budget (Qiao et al., 3 Oct 2025).

PALUTE pushes the same idea into processing-in-memory. “PALUTE: Processing-In-Memory Acceleration via Lookup Table for Edge LLM Inference” (Tian et al., 8 Jun 2026) stores LUTs in Monolithic 3D DRAM, supports in-DRAM queries, and reports $i=t[c]$25 tokens/s at $i=t[c]$26 W, $i=t[c]$27 TPS/W, $i=t[c]$28 better energy efficiency than CHIME, and $i=t[c]$29 better energy efficiency than FIGLUT under W4A4 across Qwen3-4B models (Tian et al., 8 Jun 2026). The same work also emphasizes the classic liabilities of table lookup: LUT storage overhead, table generation overhead, and lookup-latency overheads.

Across these systems, several recurring trade-offs are explicit. First, table size often grows exponentially in a grouping parameter, as in $i=t[c]$30 ternary groups (Li et al., 6 Dec 2025) or $i=t[c]$31 segment tables (Tian et al., 8 Jun 2026). Second, access locality matters as much as nominal $i=t[c]$32 lookup complexity; Vec-LUT reports that tensor-layout mismatch can degrade performance by up to $i=t[c]$33 (Li et al., 6 Dec 2025). Third, a direct table may remove arithmetic while introducing memory pressure, update cost, or routing pressure. This pattern was already visible in range-coder adaptation (Strutz et al., 3 Jan 2026), quantum compressed LUTs (Das et al., 2021), and unrolled polar hardware (Giard et al., 2023). The cumulative evidence therefore portrays table-lookup-based decoding as a high-performance but tightly co-designed technique: its benefits are largest when the state space is genuinely finite, the table can be organized around hardware locality, and update or compression mechanisms keep storage growth manageable.