Simplified SSC Decoding

• Simplified SSC decoding is a method that prunes parts of the SC tree, allowing immediate decoding of rate-0 and rate-1 subcodes to reduce latency.
• It extends traditional SC by incorporating fast-SSC techniques such as REP and SPC node decoding, improving efficiency under various hardware constraints.
• The approach is validated by asymptotic latency laws and simulation results, demonstrating significant throughput and resource optimization in hardware implementations.

Searching arXiv for the cited SSC and Fast-SSC papers to ground the article in the literature. Simplified successive-cancellation (SSC) decoding is a modification of successive-cancellation (SC) decoding for polar codes in which entire subtrees of the SC decoding tree are pruned whenever they correspond to constituent codes that can be decoded immediately, most fundamentally rate-0 and rate-1 subcodes. In the binary-input memoryless symmetric (BMS) setting, this pruning changes the latency law from the linear behavior of conventional SC to sublinear behavior under full parallelism, and to a resource-dependent law under constrained parallelism: for block length $N=2^n$, code rate $R$, scaling exponent $\mu$, and $P$ processing elements, the latency satisfies $O\!\left(N^{1-1/\mu}\right)$ in the fully-parallel regime and more generally $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$ under hardware resource constraints (Mondelli et al., 2019, Hashemi et al., 2020). In closely related literature, “fast-SSC” and fast SC decoders extend the same pruning principle to additional constituent-node classes such as repetition and single-parity-check nodes, sequence-based nodes, and non-binary special nodes (Che et al., 2015, Lu et al., 2022, Farsiabi et al., 2024).

1. SC-tree formulation and the core SSC pruning rule

SC decoding can be represented as a full binary tree of depth $n=\log_2 N$, with $N$ leaf nodes. At each node $v$, log-likelihood ratios (LLRs) $\alpha_v[i]$ propagate from parent to children, and hard decisions $R$0 propagate from children to parent. In the standard binary formulation, the left-child LLRs are computed by

$R$1

and, after decoding the left half, the right-child LLRs are computed by

$R$2

At a leaf corresponding to bit $R$3, if the position is frozen then $R$4; otherwise $R$5 for $R$6 and $R$7 for $R$8 (Che et al., 2015).

In the fully parallel time-step model used in the sublinear-latency analysis, standard SC visits the full tree, so its latency is proportional to the number of visited nodes or edges. The SC tree has $R$9 nodes, and standard SC therefore has latency $\mu$0 in that model; equivalently, standard SC traverses a full binary tree of depth $\mu$1 and has latency proportional to the number of tree edges, namely $\mu$2 (Mondelli et al., 2019, Hashemi et al., 2020).

SSC, in the sense analyzed by Alamdar-Yazdi and Kschischang and its later asymptotic study, prunes two special constituent nodes. A rate-0 node is a subtree whose leaves are all frozen, so the decoder immediately outputs all zeros. A rate-1 node is a subtree whose leaves are all information bits, so the decoder makes hard decisions in parallel directly from the input LLRs. Once such a node is identified at depth $\mu$3, the entire subtree below it is decoded in one shot and is not recursively traversed further. The resulting reduction in the number of visited nodes is the fundamental mechanism behind SSC latency reduction (Mondelli et al., 2019, Hashemi et al., 2020).

2. From SSC to fast-SSC: richer constituent-node families

Related fast-SSC literature enlarges the class of one-shot constituent decoders beyond rate-0 and rate-1. In addition to those two node types, a repetition (REP) node is a subtree in which only the last bit is information; its decision rule is based on the sign of the sum of all input LLRs,

$\mu$4

A single-parity-check (SPC) node is a subtree in which only the first bit is frozen; decoding proceeds by hard decisions $\mu$5, parity computation $\mu$6, identification of the least-reliable index $\mu$7, and, if needed, flipping that least-reliable decision (Che et al., 2015).

In the throughput-centric hardware formulation, the stated costs for these four fast constituent codes are: rate-0, 1 cycle; rate-1, 1 cycle; REP, $\mu$8 cycles to sum via an adder tree; SPC, $\mu$9 cycles for a comparator tree plus a final XOR (Che et al., 2015). In a separate FPGA-oriented time-step model with parallelism $P$0, the approximate node costs are stated differently: $P$1, $P$2, $P$3, $P$4, and $P$5 (Zheng et al., 2020). These differing figures reflect different hardware and scheduling assumptions rather than incompatible definitions.

Fast-SSC is therefore best understood as a family of SSC-derived decoders in which the pruning criterion is broadened from pure rate-0/rate-1 recognition to a catalog of constituent subcodes with closed-form or small-block decoders. This broader viewpoint also underlies later sequence-node, generalized-parity, and non-binary constructions (Lu et al., 2022, Farsiabi et al., 2024).

3. Asymptotic latency and scaling-law analysis

For a BMS channel $P$6, block length $P$7, fixed error target $P$8, and any valid upper bound $P$9 on the channel’s scaling exponent, the principal asymptotic result for SSC is

$O\!\left(N^{1-1/\mu}\right)$0

establishing sublinear latency in the block length (Mondelli et al., 2019). The scaling exponent $O\!\left(N^{1-1/\mu}\right)$1 captures the speed of polarization such that the gap to capacity $O\!\left(N^{1-1/\mu}\right)$2 scales like $O\!\left(N^{1-1/\mu}\right)$3; representative values stated in the literature are $O\!\left(N^{1-1/\mu}\right)$4 for the binary erasure channel (BEC), $O\!\left(N^{1-1/\mu}\right)$5 for AWGN, and more broadly $O\!\left(N^{1-1/\mu}\right)$6 for typical BMS channels (Hashemi et al., 2020).

The proof strategy partitions the polarization process into rounds and uses two probabilistic ingredients. First, only a vanishing fraction of synthetic channels remain unpolarized: for the random Bhattacharyya process $O\!\left(N^{1-1/\mu}\right)$7 of channel $O\!\left(N^{1-1/\mu}\right)$8,

$O\!\left(N^{1-1/\mu}\right)$9

for fixed $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$0. Second, sufficiently polarized parent channels generate subcodes that are entirely rate-0 or rate-1 and are therefore pruned. The combination implies that, except for $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$1 subtrees, the decoding tree collapses into immediately decodable constituent nodes (Mondelli et al., 2019).

The numerical validation in that analysis reports tight agreement between the asymptotic exponent and simulated latency curves. When plotting $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$2 versus $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$3 for BEC, BAWGNC, and BSC, SC exhibits slope approximately $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$4, while SSC exhibits slope approximately $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$5: for BEC, $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$6 gives slope approximately $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$7; for BAWGNC, $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$8 gives slope approximately $$O\!\left(N^{1-1/\mu}+\frac{N}{P}\log_2\log_2\frac{N}{P}\right)$$9; for BSC, $n=\log_2 N$0 gives slope approximately $n=\log_2 N$1 (Mondelli et al., 2019). The same study states that most of the latency reduction arises from the parallel decoding of subcodes of rate $n=\log_2 N$2 or $n=\log_2 N$3.

4. Parallelism, processing elements, and constrained-latency laws

The fully-parallel asymptotic law does not by itself characterize practical decoder latency, because hardware typically provides only a limited number of processing elements (PEs). In the resource-constrained analysis, $n=\log_2 N$4 denotes the number of PEs available to compute SSC node operations in parallel, with $n=\log_2 N$5. The pruned SSC decoding tree is partitioned into a top region, comprising layers up to depth approximately $n=\log_2 N$6, and a bottom region, comprising the remaining $n=\log_2 N$7-rich layers. Each edge at depth $n=\log_2 N$8 is assigned weight $n=\log_2 N$9, representing the number of time steps needed to process that edge with $N$0 PEs (Hashemi et al., 2020).

This yields the general bound

$N$1

The first term is the polarization latency, arising from decoding highly polarized subtrees in the bottom region. The second term is the serial-overhead term, arising because the top approximately $N$2 layers cannot exploit full parallelism (Hashemi et al., 2020).

Three asymptotic corollaries organize the parallelism-versus-latency trade-off. In a fully-parallel implementation with $N$3, the serial-overhead vanishes up to constants and the latency reduces to $N$4. In a fully-serial implementation with $N$5, the latency specializes to

$N$6

with dominant term $N$7, and a refined analysis yields the exact prefactor

$N$8

In a semi-parallel implementation, $N$9 is the smallest number of PEs that asymptotically matches the fully-parallel latency order $v$0 (Hashemi et al., 2020).

Simulation results in the same analysis validate both the exponent and the threshold behavior. For fully serial decoding, plots of $v$1 versus $v$2 for BEC, BAWGN, and BSC are reported as straight lines of slope approximately $v$3, confirming $v$4. For a BEC with $v$5 and $v$6, plots of $v$7 versus $v$8 for $v$9 show slopes moving from approximately $\alpha_v[i]$0 at $\alpha_v[i]$1 down to $\alpha_v[i]$2 for $\alpha_v[i]$3. The reported practical implication is that SSC achieves sublinear latency in $\alpha_v[i]$4 with moderate parallelism $\alpha_v[i]$5, and that under severe parallelism constraints $\alpha_v[i]$6 it replaces $\alpha_v[i]$7 latency with $\alpha_v[i]$8 (Hashemi et al., 2020).

5. Hardware realizations and throughput-centric design

Hardware work on fast-SSC emphasizes that algorithmic pruning is only useful if supported by a scheduling plan and datapath that preserve throughput. A representative architecture uses a binary-tree of Processing Units (PUs), where every PU can perform the standard $\alpha_v[i]$9 updates and also realize local fast-SSC operations under control signals. Because the same PU design supports both regular SC and all four fast node types, no separate specialized hardware is needed per rate. Pre-computation is used so that, in one cycle, each PU computes both $R$00 and the two possible $R$01 outputs; a multiplexer selects the correct result in the next cycle. The controller inspects the constituent-code type of the current node and branches either into a fast decode subroutine or into standard left-right recursion (Che et al., 2015).

The same implementation describes a block-level architecture consisting of LLR memory, a processing-element tree, parity-transmit units, a partial-sum generator, and a control unit/FSM. The datapath uses channel-LLRs quantized to 4 bits and inner LLRs quantized to 5-bit two’s-complement with 0 fractional bits, denoted $R$02. Only one tree is instantiated and time-multiplexed across the full $R$03 nodes. Resource sharing is central: the same PU cell handles $R$04, $R$05, SPC, REP, and regular SC, with control signals steering the datapath (Che et al., 2015).

In 45 nm Nangate FreePDK, the stated synthesis results are: maximum clock frequency 1.04 GHz; silicon area 275,899 $R$06; latency 156 cycles and throughput 5.81 Gbps for the $R$07 polar code; latency 266 cycles and throughput 2.01 Gbps for the $R$08 polar code. Compared with a 2b-SC pre-computation decoder of latency $R$09 cycles, the design is reported to achieve at least 60% latency reduction for $R$10, and up to about 85% reduction at high rates (Che et al., 2015).

A later FPGA implementation of an SR-node-based fast-SSC decoder introduces a dedicated SR module into the overall architecture, with instruction memory, controller, processing module, partial-sum network, and SR pipeline. For a length-1024 rate-1/2 polar code on an Altera Stratix IV FPGA, the implementation is reported to achieve a throughput of 505 Mbps, which is 17.9% higher than the previous work (Zheng et al., 2020). The same comparison states that, although the SR-FSSC design uses 222 clock steps rather than 214 for a prior Fast-SSC implementation, its critical path is shorter, so $R$11 increases by 10%, yielding the net throughput gain (Zheng et al., 2020). This emphasizes that SSC-family decoders are often evaluated simultaneously in terms of tree-pruning efficiency, cycle count, and clock frequency.

6. Generalizations: sequence nodes, SR nodes, and non-binary fast SC

Subsequent research extends SSC-style pruning to special-node families that are not reducible to the original rate-0/rate-1 classification. One binary extension is the SR1/SPC sequence node, denoted $R$12, in which the leftmost child at level $R$13 is a generic source node and all right descendants at levels $R$14 are either rate-1 or SPC nodes. The node depth $R$15 measures the degree of enclosed parallelism, and special cases include SR1, where all right descendants are rate-1, and SSPC, where all right descendants are SPC (Lu et al., 2022).

The decoding of SR1/SPC nodes is formulated through two families of parity constraints. Parallel parity constraints (P-PC) originate from the source node and impose

$R$16

while segmental parity constraints (S-PC) arise from the SPC descendants. The proposed generalized fast decoder is two-stage: Stage 1 corrects P-PCs by computing source-node LLRs, decoding the source, and running Wagner’s SPC decoder in parallel on the induced subcodes; Stage 2 checks S-PCs and, if necessary, performs a constrained bit-flipping correction. In the unlimited-resource model, the overall SR1/SPC decode time is $R$17 (Lu et al., 2022). For $R$18, $R$19, and $R$20 dB, the reported time-step counts are 88 for FSSC, 72 for HFSC2, and 32 for the proposed SN-FSC, corresponding to a 62.9% reduction versus FSSC and a 43.8% reduction versus HFSC2; the decoding performance is described as near-ML (Lu et al., 2022).

Another binary generalization is the sequence repetition (SR) node. An SR node, denoted $R$21, is a subtree whose descendants are rate-0 or REP nodes except for one source node at level $R$22, which may itself be rate-0, rate-1, EG-PC, or generic rate-$R$23. Decoding proceeds by forming source-node LLRs for each feasible repetition sequence, decoding the source node under each pattern, selecting the sequence maximizing the reliability metric, and reconstructing the full output by repetition and XOR. The FPGA-oriented SR-FSSC formulation gives

$R$24

with

$R$25

for launch, LLR aggregation and source decoding, selection, and partial-sum update (Zheng et al., 2020).

Non-binary polar codes constructed from $R$26 kernels admit an analogous fast SC methodology. In that setting, the decoding tree carries $R$27-ary LLR vectors over $R$28, and special nodes include rate-0, rate-1, multiplicative repetition (M-REP), and multiplicative SPC (M-SPC), along with five intermediate types (Types I–V) and two general patterns, GM-REP and GM-PC. Fast decoding avoids traversing the full tree by using closed-form symbol-LLR sums, local SPC or repetition decoders, and, in a simplified structure, fixed early-stage kernel coefficients $R$29 for all $R$30 so that small special nodes require no coefficient-dependent permutations (Farsiabi et al., 2024). The reported latency improvement is up to 95% relative to symbol-by-symbol SC, with no error-rate loss; for rate-0.5 codes over GF(16), the stated reductions are from 1020 to 178 steps at $R$31, from 2044 to 278 at $R$32, from 4092 to 438 at $R$33, and from 8188 to 623 at $R$34 (Farsiabi et al., 2024).

A plausible implication is that SSC has evolved from a narrowly defined rate-0/rate-1 pruning rule into a broader design paradigm: identify intermediate nodes whose constituent-code constraints admit parallel or near-ML local decoding, then restructure the SC schedule so that those nodes replace large recursive subtrees. The literature nonetheless retains an important distinction between original SSC, which centers on rate-0 and rate-1 pruning (Mondelli et al., 2019), and later fast-SSC or fast SC variants, which add REP, SPC, sequence, generalized-parity, and non-binary node classes (Che et al., 2015, Lu et al., 2022, Farsiabi et al., 2024).