Paper deep dive
Semantic Error Correction and Decoding for Short Block Channel Codes
Jiafu Hao, Chentao Yue, Wanchun Liu, Yonghui Li, Branka Vucetic
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 97%
Last extracted: 4/27/2026, 2:52:45 AM
Summary
The paper proposes a semantic-enhanced receiver framework for transmitting natural language over noisy wireless channels using Multiple Short Code (MSC) transmission. The framework partitions sentences into segments, each encoded with a short block code, to localize errors and preserve context. It introduces three key modules: Semantic Error Correction (SEC) using a fine-tuned BART model to reconstruct corrupted segments, Semantic List Decoding (SLD) which uses diverse beam search and weighted Hamming distance to select the best candidate, and Semantic Confidence-guided HARQ (SHARQ) which replaces CRC with a semantic confidence score for selective retransmission. Simulation results show significant BLER gains and reduced latency compared to single long LDPC codewords.
Entities (7)
Relation Signals (4)
BART → isusedfortraining → SEC
confidence 100% · All modules are designed and trained using bidirectional and auto-regressive transformers (BART).
SHARQ → replaces → CRC
confidence 100% · replaces Cyclic Redundancy Check (CRC) with a semantic confidence score
MSC → utilizes → SEC
confidence 100% · The MSC framework is illustrated in Fig. 1. ... The SEC module then takes s^ as input
SLD → improves → SEC
confidence 90% · SEC provides approximately 0.4 dB BLER gain... while SLD extends this to 0.8 dB.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:This paper presents a semantic-enhanced receiver framework for transmitting natural language sentences over noisy wireless channels using multiple short block codes. After ASCII encoding, the sentence is divided into segments, each independently encoded with a short block code and transmitted over an AWGN channel. At the receiver, segments are decoded in parallel, followed by a semantic error correction (SEC) model, which reconstructs corrupted segments using language model context. We further propose the semantic list decoding (SLD), which generates multiple candidate reconstructions and selects the best one via weighted Hamming distance, and a semantic confidence-guided HARQ (SHARQ) mechanism that replaces CRC-based error detection with a confidence score, enabling selective segment retransmission without CRC overhead. All modules are designed and trained using bidirectional and auto-regressive transformers (BART). Simulation results demonstrate that the proposed scheme significantly outperforms conventional capacity-approaching short codes and long codes at the same rate. Specifically, SEC provides approximately 0.4 dB BLER gain over plain short-code transmission, while SLD extends this to 0.8 dB. Compared to transmitting the entire sentence as a single long 5G LDPC codeword, our approach significantly improves semantic fidelity and reduces decoding latency by up to 90\%. SHARQ further provides an additional 1.5 dB gain over conventional HARQ.
Tags
Links
- Source: https://arxiv.org/abs/2604.22269v1
- Canonical: https://arxiv.org/abs/2604.22269v1
Trouble viewing inline? Open PDF directly →
Full Text
77,553 characters extracted from source content.
Expand or collapse full text
Semantic Error Correction and Decoding for Short Block Channel Codes Jiafu Hao, , Chentao Yue, , Wanchun Liu, , Yonghui Li, , and Branka Vucetic Jiafu Hao, Chentao Yue Wanchun Liu, Yonghui Li and Branka Vucetic are with the School of Electrical and Computer Engineering, The University of Sydney, Sydney, NSW 2006, Australia (e-mail: jiafu.hao; chentao.yue; wanchun.liu; branka.vucetic; yonghui.li@sydney.edu.au). (Corresponding author: Chentao Yue)Code available: https://github.com/Jeh100/SEC-for-Short-Block-Codes.git. The work of Chentao Yue was supported by ARC under Grant DE250101332. Abstract This paper presents a semantic-enhanced receiver framework for transmitting natural language sentences over noisy wireless channels using multiple short block codes. After ASCII encoding, the sentence is divided into segments, each independently encoded with a short block code and transmitted over an AWGN channel. At the receiver, segments are decoded in parallel, followed by a semantic error correction (SEC) model, which reconstructs corrupted segments using language model context. We further propose the semantic list decoding (SLD), which generates multiple candidate reconstructions and selects the best one via weighted Hamming distance. Moreover, a semantic confidence-guided HARQ (SHARQ) mechanism is designed to replaces Cyclic Redundancy Check (CRC) with a semantic confidence score, enabling selective segment retransmission. We analyze the block error rate (BLER) for the proposed framework and discuss the tradeoff between the semantic gain from segmentation and the finite-blocklength penalty of shorter codes. Simulation results demonstrate that SEC provides approximately 0.4 dB BLER gain over plain short-code transmission, while SLD extends this to 0.8 dB. Compared to transmitting the entire sentence as a single long 5G LDPC codeword, our approach significantly improves semantic fidelity and reduces decoding latency by up to 90%. SHARQ further provides an additional 1.5 dB gain over conventional HARQ. I Introduction Ultra-reliable and low-latency communications (URLLC) is one of the key 5G service paradigms. The design of the physical layer, especially the channel coding scheme, for URLLC involves a fundamental trade-off between latency and reliability [yue2023efficient]. Long blocklength codes, such as LDPC codes [1057683], can approach the Shannon capacity under Belief Propagation (BP) [Mahyar2019ShortCode]. However, their inherent long blocklength introduces significant propagation and processing latency, making them unsuited for URLLC. This motivates the use of short blocklength codes to meet the tight latency requirements. However, as established by the finite blocklength theory [PPV], shorter blocklengths inevitably lead to a degradation in error-correction capability, posing a fundamental challenge for achieving ultra-reliable transmission. Semantic communication (SemCom) has emerged as a promising paradigm for future communication systems, shifting the focus from bit-level transmission to the extraction and delivery of meaning-relevant information [9955525]. Unlike conventional approaches that prioritize every bit accuracy, SemCom aims to preserve the fidelity of transmitted meaning. Current SemCom research follows two primary directions. The first is source–channel separation coding design. They only focus on source coding, aiming to compress and transmit essential semantic content efficiently. For example, [10494374] introduced importance-weighted semantic triples to identify key semantic information, while [Lee] employed VQ-VAE for semantic compression to reduce transmission volume. Liu et al. [LIU] exploit context information within and between sentences for enhanced semantic representation and recovery. The second direction is joint source-channel coding (JSCC) that optimizes encoders and decoders jointly through end-to-end training [jscc]. JSCC completely replaces the traditional structure with a neural network. DeepJSSC [deepsc] presents a deep neural network framework that integrates semantic coding and channel coding for end-to-end transmission. Swin-JSCC [swin-jscc] leverages the Swin Transformer architecture and adaptive modules to achieve high-performance. D²-JSCC [d2jscc] combines deep source coding with adaptive density models and digital channel block coding to minimize end-to-end distortion. While these JSCC approaches achieve strong performance by jointly optimizing the entire transmission chain, they require a complete replacement of conventional communication modules with neural networks, violating the source–channel separation principle [6773024] and incurring high implementation costs. Recent advances have explored integration between SemCom and physical layer design. Some works focus on system-level integration, where Lee et al. [Lee] integrate pre-trained language models with 5G-NR physical layer functions, and Evgenidis et al. [hybird_semcom] propose a hybrid semantic-Shannon multi-carrier system that jointly optimizes transmission mode selection and power allocation. Other works exploit semantic information to enhance specific physical-layer functionalities. For example, [MIMO1] jointly designs semantic coding and massive MIMO beamforming, [LLM-aid] proposes a semantic pilot scheme leveraging LLM-corrected text for data-aided channel estimation, and [TWRC] develops a semantic-empowered physical-layer network coding framework for two-way relay channels. Semantic information has also been leveraged to improve transmission reliability and security, including semantic signals as information-bearing artificial noise for physical-layer security [secrecy]. Semantic-aware hybrid automatic repeat request (HARQ) has been explored for vehicular networks [harq], but it operates within an end-to-end JSCC framework and lacks fine-grained segment-level retransmission guided by channel soft information. Despite these advances, SemCom faces critical challenges for practical deployment in latency-sensitive applications. Source–channel separation SemCom systems typically require long codewords to represent semantic content [9955525], introducing transmission delays that conflict with strict latency requirements. These limitations motivate a different approach: rather than redesigning the entire communication chain, semantic information can be selectively incorporated into the physical layer, preserving compatibility with existing infrastructure. In this direction, Kim et al. [bit_flip] propose unequal error protection for digital semantic communication, where learned bit-flip probabilities are used to allocate coding redundancy according to semantic importance. Park and Yang [LLM-aid] leverage LLM-corrected text to identify reliable decoded symbols as semantic pilots for data-aided channel estimation. However, [bit_flip] focuses on encoder-side redundancy allocation without exploiting semantic information at the decoder, while [LLM-aid] operates on uncoded symbols and does not integrate with channel coding. The potential of semantic information to directly improve channel decoding performance remains unexplored. To address these issues, we propose a receiver-side framework that integrates a pretrained language model into the decoding process of standard short block codes, preserving the conventional source–channel separation architecture. We focus on natural-language text in this work, as it is the dominant payload in machine-to-machine signaling and the short control messages in URLLC and IoT applications. Rather than transmitting a natural-language sentence as a single long codeword, the sentence is partitioned into short segments, each independently channel-encoded and decoded. Segments that fail channel decoding are then reconstructed through semantic inference conditioned on the correctly decoded segments. The key observation is that a single long codeword fails as a whole upon decoding failure, destroying all contextual information, whereas multiple short codewords fail locally, leaving sufficient context for language-model-based recovery. While this work focuses on text, the principle applies to any structured source. The main contributions of this paper are summarized as follows. • We propose a multiple short-code (MSC) transmission framework, in which a natural-language sentence is partitioned into segments, each independently encoded by a short block code. We show that localized channel-decoding failures preserve the semantic context. Building on MSC, we propose a semantic error correction (SEC) module that replaces erroneous segments with semantically coherent reconstructions generated by a fine-tuned bidirectional and auto-regressive transformers (BART) model, exploiting cross-segment context through bidirectional self-attention. • To overcome the unverifiable nature of single-output semantic correction, we propose semantic list decoding (SLD). For each unreliable segment, SLD generates a list of candidate reconstructions via diverse beam search, re-encodes each candidate, and selects the one minimizing the weighted Hamming distance against the received soft information. This approach couples language-model reasoning with conventional bit-level channel reliability. • We propose a semantic confidence-guided HARQ (SHARQ) scheme, which replaces CRC-based error detection with a soft-information-based confidence metric. SHARQ eliminates the CRC overhead that is prohibitive for short block codes and enables segment-selective retransmission. • We derive closed-form block error rate (BLER) expressions for MSC with semantic processing. Via conditional entropy and Fano’s inequality, we provide an information-theoretic interpretation that quantifies the tradeoff between the semantic gain from segmentation and the finite-blocklength penalty of shorter codes. Simulation results on the SNLI corpus over the binary-input AWGN channel confirm the effectiveness of the proposed scheme. Under single-shot transmission, the SEC and SLD pipeline achieves a 1.11.1 dB BLER gain at 0 dB SNR over a single (1024,512)(1024,512) 5G LDPC codeword while maintaining BLEU >93>93 and ROUGE-L >97>97. SLD recovers 99%99\% of erroneous (32,16)(32,16) segments, and parallel short-code decoding reduces per-sentence latency by 7676–90%90\% relative to long-LDPC decoding. When the retransmission is enabled, SHARQ yields an additional 1.51.5 dB gain over CRC-based HARQ at the same target BLER. The remainder of this paper is organized as follows. Section I reviews the background of our proposed methods. Section I presents the MSC framework and the SEC module. Section IV develops the SLD scheme, including error identification, candidate generation, and WHD-based selection. Section V introduces the SHARQ retransmission mechanism. Section VI provides the performance and complexity analysis. Simulation results and discussions are presented in Section VII. Finally, Section VIII concludes the paper. I Background I-A Linear block code A binary linear block code (n,k)C(n,k) encodes k information bits into an n-bit codeword (n>kn>k), where the n−kn-k redundant bits provide error-correction capability. The code is defined by its generator matrix ∈0,1k×nG∈\0,1\^k× n, and encoding maps a message vector ∈0,1kb∈\0,1\^k to a codeword =∈0,1nc=bG∈\0,1\^n. The codeword c is modulated via BPSK as =1−2∈−1,+1nx=1-2c∈\-1,+1\^n and transmitted over an additive white Gaussian noise AWGN channel. The received signal is =+,y=x+z, (1) where ∼(,σ2n)z (0,σ^2I_n) is the i.i.d. Gaussian noise. The signal-to-noise ratio (SNR) is given by 1σ2 1σ^2. At the receiver, a decoder estimates the transmitted codeword as c. A decoding error occurs if ^≠ c . The best achievable BLER performance of block codes is fundamentally constrained by their blocklength. According to the normal approximation (NA) bound of the finite blocklength theory [PPV], for code (n,k)C(n,k), its best BLER in binary AWGN channels is approximately given by [erseghe2016coding]: ϵ∗(k,n)≈Q(nV⋅(C−Rlog2e+logn2n)),ε^*(k,n)≈ Q ( nV· ( C-R _2e+ n2n ) ), (2) where C is the channel capacity, V is the channel dispersion [erseghe2016coding, Fig. 6], and Q−1(⋅)Q^-1(·) is the inverse Gaussian Q-function. As shown by (2), at the same code rate R, the BLER degrades significantly as n decreases, establishing the performance penalty of short codes. I-B Ordered Statistics Decoding and Re-encoding Ordered statistics decoding (OSD) [554278] is a near-ML decoder applicable to any linear block code, operating directly on the generator matrix without requiring code-specific structure. The decoding complexity of OSD is roughly (km+2)O(k^m+2), where m=⌈dmin/4⌉m= d_ /4 is the decoding order and dmind_ is the minimum Hamming distance of the code. I-B1 OSD Preprocessing We define αi=|yi| _i=|y_i| to represent the reliability of the received symbol yiy_i. The hard-decision vector =[r]1nr=[r]_1^n is obtained by thresholding: ri=1r_i=1 for yi<0y_i<0 and ri=0r_i=0 otherwise. Prior to decoding, OSD performs two permutations on the received vector y and the generator matrix G. The first permutation π1 _1 reorders y and the columns of G according to the descending order of =[α]1n α=[α]_1^n. Subsequently, Gaussian elimination (GE) is applied to the permuted matrix π1() _1(G) to convert it into systematic form, i.e., ~=[k~], G=[I_k\ P], where kI_k denotes the k×k× k identity matrix and ~ P represents the corresponding parity sub-matrix. During the elimination process, an additional permutation π2 _2 may be introduced to guarantee that the first k columns are linearly independent. After permutation, the reordered received vector and generator matrix can be expressed as ~=π2(π1()),~=π2(π1()), y= _2( _1(y)), G= _2( _1(G)), (3) respectively. Similarly, the reliability sequence and the hard-decision vector are rearranged as ~=π2(π1()),~=π2(π1()). α= _2( _1( α)), r= _2( _1(r)). (4) For any length-n vector, subscripts (⋅)B(·)_B and (⋅)P(·)_P denote its first k and remaining n−kn-k components, respectively. Figure 1: Proposed MSC framework with parallel short block codes and SEC module. Modulation and demodulation are omitted for clarity. I-B2 Re-encoding The key insight of OSD lies in the re-encoding step. Once ~ G is in systematic form, any valid codeword is fully determined by its k systematic bits. Decoding therefore reduces to a search over hypotheses for the k-bit systematic part. Each hypothesis is expressed as a test error pattern (TEP) ∈0,1ke∈\0,1\^k applied to ~B r_B, from which a complete candidate codeword is obtained by re-encoding: ~=(~B⊕)~=[~B⊕(~B⊕)~]. c_e=( r_B ) G= [ r_B ( r_B ) P ]. (5) TEPs are evaluated in ascending order of Hamming weight. The maximum allowed Hamming weight is referred to as the OSD order. For BI-AWGN channels, the optimal codeword ~opt c_opt minimizes the weighted Hamming distance (WHD): d(W)(~,~)≜∑1≤i≤nc~,i≠y~iα~i.d^(W)( c_e, y) _ subarrayc1≤ i≤ n\\ c_e,i≠ y_i subarray α_i. (6) Finally, the decoded output c is obtained by applying the inverse permutations to ~opt c_opt, namely, ^=π1−1(π2−1(~)). c= _1^-1 ( _2^-1( c) ). (7) The proposed SLD scheme exploits this re-encoding principle. Whereas OSD enumerates information candidates by applying TEPs, SLD obtains its candidates from a language model conditioned on the surrounding context. Each candidate text segment can be mapped to a k-bit information vector, re-encoded into a length-n codeword, and ranked by the distance against the received signal. Re-encoding therefore connects semantic-level inference with bit-level channel reliability. The details will be introduced in Section IV. I-C Pretrained Language Models The Transformer architecture [NIPS2017_3f5e243] captures contextual dependencies in sequential data through self-attention mechanisms. Building on this foundation, Bidirectional and Auto-Regressive Transformers (BART) [bart] is a sequence-to-sequence model combining a bidirectional encoder with an autoregressive decoder (distinct from the channel encoder/decoder in Section I-A). BART is pre-trained as a denoising autoencoder. Specifically, given a corrupted input sequence (e.g., masking, deletion, and substitution), it learns to reconstruct the original text by minimizing a cross-entropy loss over the output tokens. This pre-training objective closely mirrors the channel decoding task, where channel decoding errors results in corrupted characters in the decoded text. Architecturally, BART’s encoder processes the entire input sequence via stacked Transformer layers [NIPS2017_3f5e243] to produce contextual representations, which capture dependencies across all input positions through self-attention. The decoder autoregressively generates output tokens conditioned on these representations and all previously generated tokens. For tokenization, BART employs byte-pair encoding (BPE) [BPE] tokenization, which maps an input string into subword tokens drawn from a fixed learned vocabulary. I Proposed Semantic Error Correction Scheme I-A System Overview We consider the transmission of a natural language sentence s with character length ℓ over a noisy channel. Each character is first converted to its 8-bit ASCII representation, resulting in a binary bit stream ′b with k′=8ℓk =8 bits. TABLE I: Examples of MSC with SEC for different error scenarios using the (128,64)(128,64) code at SNR = 2 dB. Original Sentence s Before SEC s After SEC ^SEC s_SEC A lady in a blue shirt and hat dancing with … c/?ueK(y⏟Error c/?ueK(y_Errorn a blue shirt and hat dancing with … A girl in a blue shirt and hat dancing with … one little boy are running on the grass. … one little [?yX#Gg?⏟Error [?yX\#Gg?_Errorrunning on the grass. … one little boy are running on the grass. I-A1 Multiple Short Code (MSC) Transmission The MSC framework partitions the sentence into q independently encoded segments. A failure in one segment leaves the remaining q−1q-1 segments intact, providing the language model with reliable context for reconstruction. Formally, s is divided into q segments of equal character length lMSC=ℓ/ql_MSC= /q. After ASCII conversion, this yields q bitstreams 1,…,q\b_1,…,b_q\, each of length k=k′/qk=k /q. Each segment ib_i is independently encoded by a MSC(n,k)C_MSC(n,k) code with generator matrix MSCG_MSC, producing codewords 1,…,q\c_1,…,c_q\ each of length n. The q codewords are concatenated and transmitted over an AWGN channel via BPSK modulation, as described in Section I-A. At the receiver, each segment iy_i is independently decoded using OSD. We define αi,j=|yi,j| _i,j=|y_i,j| as the reliability of the j-th received symbol in segment i, and denote the reliability vector of segment i by i=[αi,1,…,αi,n] α_i=[ _i,1,…, _i,n]. As described in Section I-B, the received segment iy_i undergoes the permutations ~i=π2(π1(i)) y_i= _2( _1(y_i)), and then all TEPs are evaluated to identify the optimal codeword. We denote the optimal decoding output of iy_i by ^i c_i, whose information bits are ^i b_i. The concatenated estimates ^=[^1,…,^q] b=[ b_1,…, b_q] are mapped by ASCII source decoding to the sentence estimate ^=s^1,…,s^q s=\ s_1,…, s_q\, with each s^i s_i of length lMSCl_MSC. The SEC module then takes s as input, to reconstruct the corrupted segments and recover the full sentence s. The MSC framework is illustrated in Fig. 1. I-A2 Long Code (LC) Transmission Baseline For comparison, we consider a conventional scheme where the complete bitstream ′b is encoded as a single LC(n′,k′)C_LC(n ,k ) LDPC codeword and decoded via BP. Both MSC and LC schemes operate at the same code rate R=k/n=k′/n′R=k/n=k /n , ensuring fair performance comparison. Despite equal code rates, the two schemes exhibit fundamentally different error characteristics. Under LC, redundancy is distributed globally; when BP decoding fails, the entire sentence is corrupted and no contextual information survives for semantic recovery. Under MSC, failures are localized to individual segments. Correctly decoded segments provide partial context essential for reconstruction. Remark 1 This work adopts ASCII encoding as the source coding scheme. However, any fixed-rate source coding scheme that produces a binary bitstream of known length k′k can be employed directly in the MSC framework. For variable-rate source coding, such as Huffman or arithmetic coding, error propagation across segment boundaries should be considered, since a single corrupted bit can invalidate the source decoding of subsequent symbols. In such cases, segment boundaries should be aligned with source coding units to preserve the localized failure property that enables semantic recovery. Figure 2: SLD processing flow. BART generates multiple candidate segments for error segments. Candidates are re-encoded and ranked by WHD. The minimum-distance candidate is selected for each segment to construct the final output ^SLD s_SLD I-B Semantic Error Correction (SEC) The sentence estimate s is fed into the SEC module. SEC operates as a denoising step at the sentence level through the BART model. I-B1 SEC Processing The input s is first tokenized using the pretrained BPE function fBPE(⋅)f_BPE(·) introduced in Section I-C: ^=fBPE(^)=[t^1,t^2,…,t^z], t=f_BPE( s)=[ t_1, t_2,…, t_z], [rgb]0,0,1 (8) where z is the token sequence length, which varies with sentence content. Each token t^i t_i is a high-dimensional vector representing a subword unit from the sentence, which may be a complete word, a word fragment, or even a single character, depending on the tokenization process. When channel decoding errors introduce garbled or out-of-vocabulary characters, BPE recursively decomposes them into individual characters, ensuring the tokenizer remains well-defined under arbitrary corruption. The token sequence t is passed to the BART correction model: ^SEC=fSEC(^;SEC), s_SEC=f_SEC( t;\, θ_SEC), (9) where ^SEC=^SEC,1,^SEC,2…,^SEC,q s_SEC=\ s_SEC,1, s_SEC,2…, s_SEC,q\ is the corrected sentence and SEC θ_SEC is the fine-tuned model parameters. BART’s bidirectional encoder captures dependencies across all segments simultaneously, allowing correctly decoded segments to inform the reconstruction of corrupted ones. Table I illustrates the SEC pipeline for error scenarios using (128,64)(128,64) codes at SNR=2dBSNR=2\,dB. The full sentence is transmitted using q=8q=8. Even when a segment is severely corrupted (e.g., “c/?ueK(y”), SEC recovers a semantically plausible substitution from the surrounding context. Note that the recovered segment can still be different to the original. The confidence scoring in Section IV can determine whether the correction is reliable. The training process of SEC will be detailed in Section VII-A1. IV Proposed Semantic List Decoding Scheme SEC relies solely on context reasoning, so its errors remain grammatically and semantically plausible and cannot be detected from text alone. For example, as shown in Table I, if “A lady i” is corrupted in “A lady in a blue shirt …” , SEC may infer “A girl i” based on context. To address this, SLD introduces two stages: error identification and list-based correction, as illustrated in Fig. 2. The error identification step detects segments where the SEC reconstruction is unreliable by comparing the re-encoded SEC output against the received signal. For each identified unreliable segment, the list-based correction step generates multiple candidate reconstructions and selects the most reliable one using weighted Hamming distance against the received signal. IV-A Error identification SEC operates at the text level, whereas the proposed error identification requires comparison against the received signal in the codeword domain. We therefore re-encode each SEC output segment back into a codeword and measure its consistency with the channel observation. For the i-th segment after SEC processing, ^SEC,i s_SEC,i is first converted to its k-bit ASCII representation ^SEC,i b_SEC,i, and then re-encoded into a length-n codeword ^SEC,i=^SEC,iMSC c_SEC,i= b_SEC,iG_MSC. Applying the OSD permutations from Section I-B yields the permuted codeword ~SEC,i=π2(π1(^SEC,i)) c_SEC,i= _2( _1( c_SEC,i)). For notational simplicity, the segment index i is omitted in the following, i.e., ~SEC=~SEC,i c_SEC= c_SEC,i. The re-encoded codeword ~SEC c_SEC implicitly defines a TEP SEC=~B⊕~SEC,Be_SEC= r_B c_SEC,B on the first k systematic bits. Unlike conventional OSD, which enumerates TEPs of Hamming weight up to m, the TEP SECe_SEC can have arbitrary weight and originates from semantic inference rather than systematic enumeration. To assess whether this semantically-derived TEP is reliable, we compute its success probability PSEC,iP_SEC,i, defined as the a posteriori probability that SECe_SEC correctly identifies the true channel error pattern: PSEC,i≜Pr(~B=SEC∣SEC),P_SEC,i ( e_B=e_SEC _SEC ), (10) where SEC=~SEC⊕~d_SEC= c_SEC r is the difference pattern between the re-encoded codeword and the hard-decision received vector, and Pr(~B=SEC) ( e_B=e_SEC) is the a priori probability of ~B=SEC e_B=e_SEC. Let SECD_SEC denote the random variable corresponding to SECd_SEC. For notational brevity, we write Pr(SEC) (d_SEC) for Pr(SEC=SEC) (D_SEC=d_SEC) in the following. Applying the probability analysis framework in [pbosd], PSEC,iP_SEC,i can be expressed via Bayes’ theorem as PSEC,i=Pr(SEC|~B=SEC)Pr(~B=SEC)Pr(SEC).P_SEC,i= (d_SEC| e_B=e_SEC) ( e_B=e_SEC) (d_SEC). (11) Following [pbosd], PSEC,iP_SEC,i can be approximated as PSEC,i≈(1+(1−P(SEC))2k−nP(SEC)∏k≤j≤ndSEC,j≠0P(j)∏k≤j≤ndSEC,j=0(1−P(j)))−1,P_SEC,i≈ (1+ (1-P(e_SEC))2^k-nP(e_SEC) _ subarrayck≤ j≤ n\\ d_SEC,j≠ 0 subarray\!\!P(j) _ subarrayck≤ j≤ n\\ d_SEC,j=0 subarray\!\!(1-P(j)) )^\!-1\!\!, (12) where P(j)≈(1+exp(2αj))−1P(j)≈(1+ (2 _j))^-1 is the bit error probability at position j given reliability αj _j, and P(SEC)P(e_SEC) is the prior probability of the error pattern SECe_SEC computed from the individual bit error probabilities as detailed in [pbosd, Eq. (5)]. Segments ^SEC,i s_SEC,i with PSEC,i<TSECP_SEC,i<T_SEC form the error set, i.e., err=i:PSEC,i<TSECS_err=\i:P_SEC,i<T_SEC\ where TSEC∈(0,1)T_SEC∈(0,1) is a confidence threshold. If all segments meet the threshold (err=∅S_err= ), SEC outputs are used directly without further processing. IV-B Semantic List Decoding SLD refines SEC outputs when error identification detects unreliable segments (err≠∅S_err≠ ). To process each ^SEC,i∈err s_SEC,i _err, we assume all other segments ^SEC,j s_SEC,j (j≠i)(j≠ i), are correct. Then, we replace ^SEC,i s_SEC,i with the special symbol ⟨mask⟩ from the BPE vocabulary, yielding the masked sentence ^SEC′=^SEC,1,…,⟨mask⟩i,…,^SEC,q. s_SEC =\ s_SEC,1,…, _i,…, s_SEC,q\. (13) IV-B1 SLD Processing ^SEC′ s _SEC is tokenized to obtain: ^′=fBPE(^SEC′)=[t^1′,t^2′,…,t^z′], t =f_BPE( s_SEC )=[ t _1, t _2,…, t _z ], (14) where z′z is the length of the masked token sequence. The token sequence ^′ t is passed to the BART model to generate V candidate sentences via SLD=fSLD(^′;SLD,V),C_SLD=f_SLD( t ; θ_SLD,V), (15) where SLD=^SLD1,…,^SLDVC_SLD=\ s^1_SLD,…, s^V_SLD\ denotes the set of V candidate reconstructions and SLD θ_SLD denotes the fine-tuned model parameters. Unlike SEC, which produces a single output, SLD retains the top-V high-probability sequences from BART’s autoregressive decoding to form a diverse candidate set. The specific strategy used to generate SLDC_SLD is detailed in Section VII. Generating multiple candidates, however, raises an alignment problem. BART produces each candidate one token at a time. Different candidates may use different numbers of tokens, so the reconstructed segment can appear at different character positions across SLDC_SLD. Fixed-length slicing as in MSC is therefore no longer valid; we need to locate each masked segment within each candidate. IV-B2 Locating the Reconstructed Content For each masked segment i∈erri _err, we extract its candidate segments from the V candidate sentences as i=fextract(SLD,^SEC′,i),D_i=f_extract(C_SLD, s_SEC ,i), (16) where each element of iD_i has length lMSCl_MSC. The extraction function fextract(⋅,⋅,⋅)f_extract(·,·,·) locates the reconstructed content for each masked segment i∈erri _err in each candidate ^SLDv∈SLD s_SLD^v _SLD. Since correctly decoded segments are preserved across all candidates, they serve as anchors that localize the reconstructed content despite the length variations. The extraction proceeds as follows. • Leading segment (i=1i=1): No preceding anchor exists. The first lMSCl_MSC characters are directly extracted from each candidate ^SLDv∈SLD s^v_SLD _SLD. • Non-leading segment (i>1i>1): If i−1∉erri-1 _err, the preceding segment ^SEC,i−1 s_SEC,i-1 serves as the anchor. The subsequent lMSCl_MSC characters are extracted. • Consecutive masked segments (i,i+1,…,i+ri,i+1,…,i+r for r≥1r≥ 1): The nearest reliable segment preceding the group serves as the anchor, after which r+1r+1 consecutive blocks of length lMSCl_MSC are extracted. Figure 3 illustrates this procedure. Applying it to all V candidates yields the candidate segment set i=^SLD,i1,…,^SLD,iv,…,^SLD,iVD_i=\ s^1_SLD,i,…, s^v_SLD,i,…, s^V_SLD,i\. IV-C Weighted Hamming Distance Selection Since all candidates in iD_i are semantically plausible, we perform bit-level selection by evaluating each candidate’s distance against the received signal. Each candidate segment ^SLD,iv s^v_SLD,i is first converted to its k-bit ASCII representation ^SLD,iv b^v_SLD,i, then re-encoded using the generator matrix MSCG_MSC to obtain the codeword ^SLD,iv=^SLD,ivMSC c^v_SLD,i= b^v_SLD,iG_MSC. The weighted Hamming distance d(W)(^SLD,iv,i)d^(W)( c^v_SLD,i,y_i) between ^SLD,iv c^v_SLD,i and iy_i is then computed following (6). Re-encoding maps each semantically generated candidate back to the codeword domain, enabling direct comparison with the channel observation. When the correct segment is contained in iD_i, its re-encoded codeword typically achieves the lowest WHD, as it is closest to the transmitted codeword. For each erroneous segment i∈erri _err, we select the candidate minimizing the WHD: ^SLD,iopt=argmin^SLD,iv∈id(W)(^SLD,iv,i). s^opt_SLD,i= _ s^v_SLD,i _id^(W)( c^v_SLD,i,y_i). (17) Figure 3: Illustration of reconstructed contents extraction with err=1,4,5S_err=\1,4,5\. Segment 1 is extracted as a leading segment. Segments 4 and 5 are consecutive masked segments. Figure 4: Example of WHD selection in SLD: candidates in 4D_4 are re-encoded and ranked by their WHD against 4y_4; ”powerful” achieves the minimum distance and is selected. Algorithm 1 MSC Receiver with SEC and SLD 0: Received signal =[1,…,q]y=[y_1,…,y_q], generator matrix MSCG_MSC, confidence threshold TSECT_SEC, candidate list size V 0: Decoded sentence s 1: for i=1,…,qi=1,…,q in parallel do 2: ^i←OSD(i) b_i (y_i) // Stage 1: Parallel Channel Decoding 3: s^i←fASCII−1(^i) s_i← f_ASCII^-1( b_i) 4: end for 5: ^SEC←fSEC(fBPE(^);SEC) s_SEC← f_SEC(f_BPE( s); θ_SEC) // Stage 2: Semantic Error Correction 6: for i=1,…,qi=1,…,q do 7: ^SEC,i←fASCII(s^SEC,i)MSC c_SEC,i← f_ASCII( s_SEC,i)\,G_MSC // Re-encoding 8: Compute PSEC,iP_SEC,i via (12) 9: end for 10: err←i:PSEC,i<TSECS_err←\i:P_SEC,i<T_SEC\ // Error Identification 11: if err=∅S_err= then 12: return ^SEC s_SEC 13: end if 14: Form ^SEC′ s _SEC for all i∈erri _err via (13) // Stage 3: List Decoding 15: Generate V candidates SLDC_SLD via (15) 16: for each i∈erri _err do 17: Extract candidate set iD_i via (16) 18: Re-encode each s^SLD,iv∈i s^v_SLD,i _i into ^SLD,iv c^v_SLD,i 19: Evaluate d(W)(^SLD,iv,i)d^(W)( c^v_SLD,i,y_i) via (6) 20: Select s^SLD,iopt s^opt_SLD,i via (17) 21: end for 22: return ^SLD s_SLD via (18) The final SLD output is constructed by replacing each erroneous segment with its optimal candidate while preserving SEC outputs at other segments: ^SLD=^SLD,ioptif i∈err,^SEC,iotherwise. s_SLD= \ array[]l s^opt_SLD,i&if i _err,\\ s_SEC,i&otherwise. array . (18) Only segments flagged as unreliable are refined by SLD. Figure 4 illustrates this selection process for an example segment. IV-D Algorithm Algorithm 1 summarizes the complete MSC receiver. It proceeds in three stages: parallel OSD decoding of the q segments, SEC with error identification, and SLD refinement of the identified erroneous segments. V Semantic Retransmission Scheme Even with SLD, some segments may remain unreliable when both semantic context and channel information are insufficient. This can be further resolved by retransmission. Conventional HARQ detects errors via CRC and retransmits the entire message or additional parity-check bits upon failure. We propose SHARQ, which retransmits only the segments identified as unreliable. V-A Error Identification Even after SLD selection, ^SLD,iopt≠i s^opt_SLD,i _i remains possible when (i) the true segment is_i is not generated by the language model, so i∉is_i _i, or (i) the channel reliability i α_i is too low for WHD to discriminate among candidates. We therefore compute PSLD,iP_SLD,i, defined analogously to (12) but evaluated at the re-encoded optimal candidate ^SLD,iopt=fASCII(^SLD,iopt)MSC c^opt_SLD,i=f_ASCII( s^opt_SLD,i)\,G_MSC. As PSLD,iP_SLD,i combines the language-model-induced prior (through iD_i) with the channel soft information (through i α_i), it serves as a joint semantic–channel confidence score. Segments with confidence below a threshold Tharq∈(0,1)T_harq∈(0,1) are marked for retransmission, harq=i:PSLD,i<Tharq.S_harq=\i:P_SLD,i<T_harq\. V-B Semantic Confidence-Guided HARQ When harq≠∅S_harq≠ , the receiver requests retransmission of the segments indexed by harqS_harq. When the retransmission budget is constrained to M<|harq|M<|S_harq| segments, the receiver requests the M segments with the lowest confidence (i.e., PSLD,iP_SLD,i). Following incremental redundancy (IR) HARQ, the transmitter sends additional parity bits for each requested segment, received as i∗y^*_i.The receiver concatenates the retransmitted and original observations, ir=[i,i∗],i∈harq,y_i^r=[y_i,y_i^*], i _harq, (19) and decodes them via OSD and ASCII source decoding to obtain the updated segment estimates ^ir s^r_i. The updated sentence estimate is assembled as ^r=^irif i∈harq^SLD,iotherwise. s^r= cases s_i^r&if i _harq\\ s_SLD,i&otherwise. cases (20) The assembled ^r s^r is then re-processed through the full SEC and SLD pipeline, which produces a new error set harqrS^r_harq. Retransmission rounds can continue until harqr=∅S^r_harq= or the maximum number of rounds is reached. V-C Elimination of CRC Overhead Conventional HARQ appends a kcrck_crc-bit CRC to each segment’s information bits for error detection, reducing the effective code rate from R=k/nR=k/n to (k−kcrc)/n(k-k_crc)/n. The overhead ratio ρcrc=kcrc/k _crc=k_crc/k is negligible for long codes. For example, a 16-bit CRC on a (1024,512)(1024,512) codeword yields ρcrc=3.1% _crc=3.1\%. However, it becomes prohibitive for short codes: an 8-bit CRC on a (32,16)(32,16) code halves the throughput (ρcrc=50% _crc=50\%). SHARQ eliminates this overhead by replacing the CRC with PSLD,iP_SLD,i, which is computed directly from the channel reliabilities α and carries no transmitted redundancy. The effective rate therefore equals the nominal rate R, and the throughput gain over CRC-HARQ is G=k−kcrc−1=kcrck−kcrc,G= kk-k_crc-1= k_crck-k_crc, (21) independent of the number of segments q. VI Performance and Complexity Analysis VI-A SEC Analysis VI-A1 Analytical Framework Let ℰ⊆1,…,qE \1,…,q\ denote the set of segments that are erroneous after OSD decoding, and let qe=|ℰ|q_e=|E|. For segment i∈ℰi , let RiR_i denote the event that the semantic module successfully recovers segment i. In general, ℙ(Ri∣i∈ℰ)P(R_i i ) depends on which segments fail and on their semantic content, which makes a closed-form analysis intractable. Therefore, we adopt the following simplification. Assumption 1: The recovery probability of any erroneous segment depends on the error pattern ℰE only through its cardinality qe=|ℰ|q_e=|E|. We accordingly define Prec(qe)≜ℙ(Ri∣i∈ℰ,|ℰ|=qe),P_rec(q_e) (R_i i ,\,|E|=q_e), (22) which is independent of the segment index i and of the specific positions of the other erroneous segments. Table I reports Prec(qe)P_rec(q_e) measured at SNR =1.5=1.5 dB for qe≤4q_e≤ 4, with Prec(0)≜1P_rec(0) 1 since no recovery is needed when all segments decode correctly. Entries for qe=4q_e=4 on longer codes such as (128,64)(128,64) are omitted, as the event is exceedingly rare at this SNR. As seen, Prec(qe)P_rec(q_e) decreases monotonically with qeq_e for every code configuration, reflecting the loss of contextual segments available for reconstruction. Furthermore, at the same qeq_e, shorter codes yield higher recovery probabilities, because each failure spans fewer characters. TABLE I: Empirical recovery probability Prec(qe)P_rec(q_e) for qe≤4q_e≤ 4 at SNR =1.5=1.5 dB. (64,32)C(64,32) (128,64)C(128,64) (256,128)C(256,128) qeq_e q=16q=16 q=8q=8 q=4q=4 0 1 1 1 1 0.898 0.635 0.227 SEC 2 0.827 0.525 0.250 3 0.735 0.111 – 4 0.608 – – The statistical recovery rate η=∑qe=1qPrec(qe)⋅ℙ(|ℰ|=qe),η= _q_e=1^qP_rec(q_e)·P(|E|=q_e), (23) is a weighted average of Prec(qe)P_rec(q_e) over all error multiplicities. Since the q segments are independently decoded and experience i.i.d. channel noise, the number of erroneous segments follows a binomial distribution: ℙ(|ℰ|=qe)=(qqe)(PeOSD)qe(1−PeOSD)q−qe,P(|E|=q_e)= qq_e(P_e^OSD)^q_e(1-P_e^OSD)^q-q_e, (24) where PeOSDP_e^OSD is the per-segment OSD block error probability. For an order-m OSD applied to a (n,k)C(n,k) code, a decoding error occurs when the number of channel errors in the k most reliable positions exceeds m. Let pE1k(j)p_E_1^k(j) denote the probability that exactly j of these k positions are in error, as characterized by [pbosd, Lemma 1]. Then PeOSD≈∑j=m+1kpE1k(j)+PML,P_e^OSD≈ _j=m+1^kp_E_1^k(j)+P_ML, (25) where pE1k(j)p_E_1^k(j) is given by [pbosd, Eq. (12)] and depends on the SNR through the bit error probabilities of the ordered reliability positions. Here, PMLP_ML is the maximum-likelihood error probability of MSC(n,k)C_MSC(n,k), which is an inherent property of the code. Therefore, we have η=∑qe=1qPrec(qe)⋅(qqe)(PeOSD)qe(1−PeOSD)q−qe.η= _q_e=1^qP_rec(q_e)· qq_e(P_e^OSD)^q_e(1-P_e^OSD)^q-q_e. (26) To derive the sentence-level BLER, we require one additional assumption. Assumption 2: Given the number of erroneous segments qeq_e and the channel observations, the recovery outcomes of individual erroneous segments are mutually independent, each succeeding with probability Prec(qe)P_rec(q_e). Under this assumption, the probability that all qeq_e erroneous segments are simultaneously recovered is [Prec(qe)]qe[P_rec(q_e)]^q_e. Averaging over the binomial distribution of qeq_e yields BLER=1−∑qe=0q(qqe)(PeOSD)qe(1−PeOSD)q−qe[Prec(qe)]qe,BLER=1- _q_e=0^q qq_e(P_e^OSD)^q_e(1-P_e^OSD)^q-q_e\,[P_rec(q_e)]^q_e, (27) If Prec(qe)P_rec(q_e) is approximated by η independent of qeq_e, we have BLER≈1−(1−PeOSD(1−η))q.BLER≈ 1- (1-P_e^OSD(1-η) )^q. (28) VI-B Extension to SLD The above analytical framework cannot directly apply to SLD. The recovery event for SLD decomposes as PrecSLD(qe)=Pcover(qe)⋅Pselect(qe).P_rec^SLD(q_e)=P_cover(q_e)· P_select(q_e). (29) Given a candidate set, PselectP_select reduces to a minimum-distance decoding problem over |i||D_i| codewords and is amenable to channel-coding analysis. The coverage probability PcoverP_cover, however, depends on the language model’s distribution, the candidate diversity, and the available semantic context. These factors are determined by training data and model architecture rather than by channel or coding parameters. VI-C Information-Theoretic Interpretation We provide an information-theoretic interpretation of the proposed framework. Let ℰ⊆1,…,qE \1,…,q\ denote the set of erroneous segments after channel decoding, and let ℰ=sii∈ℰs_E=\s_i\_i and ℰ¯=sjj∉ℰs_ E=\s_j\_j denote the erroneous and correctly decoded segments, respectively. VI-C1 Residual uncertainty after decoding failure Under LC, a decoding failure corrupts the entire sentence. The receiver retains only the channel observation y, so the residual uncertainty is HLC≜H(∣,ℱLC)=H(∣).H_LC H(s ,F_LC)=H(s ). (30) where ℱLCF_LC denotes the LC decoding failure event. Under MSC, the correctly decoded segments ℰ¯s_ E are known exactly, and the residual uncertainty is HMSC≜H(∣,ℰ¯)=H(ℰ∣,ℰ¯),H_MSC H(s ,s_ E)=H(s_E ,s_ E), (31) where the equality follows because ℰ¯s_ E is a deterministic function of s, so conditioning on it eliminates uncertainty in the known segments. VI-C2 Information gain from correctly decoded segments The reduction in uncertainty provided by MSC over LC is HLC−HMSC H_LC-H_MSC =H(∣)−H(ℰ∣,ℰ¯) =H(s )-H(s_E ,s_ E) =H(ℰ¯∣)+I(ℰ¯;ℰ∣), =H(s_ E )+I(s_ E;s_E ), (32) where the first term H(ℰ¯∣)H(s_ E ) accounts for the uncertainty in ℰ¯s_ E that is resolved by successful decoding, and the second term I(ℰ¯;ℰ∣)I(s_ E;\,s_E ) is the mutual information between correctly decoded and erroneous segments given the channel observation. Both terms are non-negative, thus HMSC≤HLC.H_MSC≤ H_LC. (33) The inequality is strict whenever ℰ≠1,…,qE≠\1,…,q\, i.e., at least one segment is correctly decoded. The mutual information term I(ℰ¯;ℰ∣)I(s_ E;\,s_E ) captures the semantic side information that the language model exploits; rigorous characterization of this quantity for natural language remains open. VI-C3 Connection to recovery probability Fano’s inequality links the conditional entropy and the recovery error probability. Let Pe,i=Pr(s^i≠si∣i∈ℰ)P_e,i= ( s_i≠ s_i i ) denote the probability that the semantic module fails to recover segment i. Then H(si∣,ℰ¯)≤1+Pe,ilog2(|i|−1),H(s_i ,s_ E)≤ 1+P_e,i _2(|S_i|-1), (34) where |i|=2k|S_i|=2^k is the cardinality of the segment alphabet, since each segment carries k information bits. Equivalently, Pe,i≥H(si∣,ℰ¯)−1log2(|i|−1)≈H(si∣,ℰ¯)−1kP_e,i≥ H(s_i ,s_ E)-1 _2(|S_i|-1)≈ H(s_i ,s_ E)-1k (35) where we used log2(2k−1)≈k _2(2^k-1)≈ k for k≥1k≥ 1. The bound shows that the recovery error probability is at least proportional to the ratio of the residual conditional entropy to the segment length. As qeq_e increases, fewer segments are available in ℰ¯s_ E, so H(si∣,ℰ¯)H(s_i ,s_ E) is non-decreasing in qeq_e. The lower bound on Pe,iP_e,i therefore tightens with qeq_e, consistent with the empirical decrease of PrecP_rec in Table I. VI-C4 Segmentation tradeoff The Fano bound in (35) suggests a tradeoff in choosing the segmentation factor q for a fixed total information length k′=qk =qk. Two competing effects act on the Fano ratio (H(si∣,ℰ¯)−1)/k(H(s_i ,s_ E)-1)/k as q varies. We decompose the conditional entropy as H(si∣,ℰ¯)=H(si∣)−I(si;ℰ¯∣).H(s_i ,s_ E)=H(s_i )-I(s_i;\,s_ E ). (36) The second term I(si;ℰ¯∣)I(s_i;\,s_ E ) captures the semantic gain from context. For a fixed context fraction (q−qe)/q(q-q_e)/q, increasing q shrinks each segment to fewer characters while the relative amount of context grows in proportion. Since natural language exhibits strong inter-segment dependencies, this favors a larger mutual information per erroneous segment, which lowers the conditional entropy and the Fano ratio. The opposing effect is the finite-blocklength penalty. As q increases, each segment uses a shorter code (k′/(qR),k′/q)C(k /(qR),\,k /q) operating deeper in the finite-blocklength regime. By the normal approximation (2), the per-segment OSD error probability PeOSD(k′/q)P_e^OSD(k /q) grows with q, so [qe]=q⋅PeOSD(k′/q)E[q_e]=q· P_e^OSD(k /q) rises and the context set |ℰ¯|=q−qe| E|=q-q_e shrinks. This reduces the mutual information that the semantic gain relies on. The optimal q∗q^* minimizing the BLER in (27) therefore balances these two effects. Its value depends on both the operating SNR and the entropy structure of the source language, which is examined empirically in Section VII-C. VI-D Complexity of Semantic Module Let z denote the token sequence length after BPE tokenization. Since BART adopts the standard Transformer architecture [NIPS2017_3f5e243], its computational complexity follows directly from the per-layer analysis therein. We denote the number of encoder and decoder layers by LeL_e and LdL_d, the hidden dimension by d, and the vocabulary size by lvocl_voc. VI-D1 BART Encoder Complexity Following the Transformer architecture [NIPS2017_3f5e243], each encoder layer has per-layer complexity (z2d)O(z^2d) for self-attention and (zd2)O(zd^2) for the linear projections and feed-forward network. The total encoder complexity is enc≈Le(z2d+zd2).O_enc≈ L_e(z^2d+zd^2). (37) VI-D2 BART Decoder Complexity In addition to the self-attention and feed-forward components shared with the encoder, each decoder layer includes encoder-decoder cross-attention with (z2d)O(z^2d) cost and a vocabulary projection with (zlvocd)O(zl_vocd) cost. The total decoder complexity is dec≈Ld(z2d+zd2+zlvocd).O_dec≈ L_d(z^2d+zd^2+zl_vocd). (38) VI-D3 SEC and SLD Complexity SEC generates a single output sequence, so the encoder and decoder each execute once. The overall complexity is SEC=enc+dec.O_SEC=O_enc+O_dec. (39) SLD maintains a candidate set of size V throughout the autoregressive token generation, enlarging the decoder cost by a factor of V. Since all candidates share the same encoder output, the overall complexity is SLD=enc+V⋅dec.O_SLD=O_enc+V·O_dec. (40) VI-D4 Comparison to Channel Decoding The semantic module and the channel decoder exhibit fundamentally different complexity structures. Order-m OSD has complexity (km+2)O(k^m+2) per segment [yue2025guesswork], which grows rapidly with the decoding order m=⌈dmin/4⌉m= d_ /4 and the information length k. In contrast, the semantic module complexity is polynomial in the token sequence length z and the model dimension d, independent of the code parameters (n,k)(n,k). Furthermore, OSD is applied independently to each of the q segments and can be fully parallelized, whereas the semantic module processes the entire sentence in a single pass to exploit cross-segment context. Consequently, the semantic overhead is a fixed per-sentence cost that does not scale with q. VII Experimental Results and Discussion VII-A Implementation Details VII-A1 Dataset and Training We use the Stanford Natural Language Inference (SNLI) corpus [snli], selecting 20,000 sentences for training and 500 for testing. Sentence character lengths ℓ range from 57 to 64; zero-padding is applied to ensure fixed 512-bit inputs (64 bytes) after ASCII encoding. For SEC training, we construct a dataset SEC=((j),^(j))j=1ND_SEC=\(s^(j), s^(j))\_j=1^N, where each pair consists of an original sentence (j) s^(j) and its corrupted estimate ^(j) s^(j) obtained after channel encoding, AWGN transmission, and OSD decoding. Each sentence is transmitted 10 times at various SNRs with independent noise realizations, yielding N=200,000N=200,000 training pairs. For SLD training, we construct SLD=((j),mask(j))j=1ND_SLD=\(s^(j),s_mask^(j))\_j=1^N from the SEC training data by replacing erroneous segments with ⟨mask⟩ tokens, generating 200,000 masked sentence pairs. Both models are fine-tuned from BART-base by minimizing the token-level cross-entropy ℒ=−1N∑j=1N∑t=1TjlogP(t(j)|<t(j),~(j)),L=- 1N _j=1^N _t=1^T_j P\! (s^(j)_t\, |\,s^(j)_<t,\, s^(j) ), (41) where ~(j) s^(j) is the input sentence of the j-th training pair, namely ^(j) s^(j) for SEC and smask(j)s^(j)_mask for SLD. Then, t(j)s^(j)_t denotes the t-th target token of the reference sentence (j)s^(j) of length TjT_j. The conditional probability is produced by BART’s autoregressive decoder. The AWGN channel and all channel coding/decoding pipelines are implemented in Sionna [sionna]. For the (256,128)(256,128) code, OSD decoding is computationally prohibitive, so the corresponding BLER curve is replaced by the normal approximation bound [PPV]. SEC and SLD share the same BART-base backbone [bart], fine-tuned on a single NVIDIA A10G GPU. SLD candidate generation uses diverse beam search [beam_search] with V=20V=20 candidates partitioned into G=4G=4 groups and diversity strength λ=0.8λ=0.8. All hyperparameters are listed in Table I. Figure 5: Performance of proposed (128,64) MSC scheme and two pipeline comapred to LC scheme in BLER, BLEU, and ROUGE. VII-A2 Benchmarks We compare the following methods: • LC: LDPC code with (n′,k′)=(1024,512)(n ,k )=(1024,512), decoded via BP with 80 iterations. • MSC: We evaluate codes (n,k)C(n,k) with (n,k)∈(32,16),(64,32),(128,64),(256,128)(n,k)∈\(32,16),(64,32),(128,64),(256,128)\. A 512-bit sentence is segmented into q∈32,16,8,4q∈\32,16,8,4\ parts for independent encoding. Each segment is decoded using OSD with order m=⌊dH/4−1⌋∈2,2,4,8m= d_H/4-1 ∈\2,2,4,8\. • MSC-SEC: MSC followed by the SEC module • MSC-SLD: MSC followed by the SEC and SLD module For HARQ evaluation, MSC schemes use CRC-aided polar codes decoded by OSD, while LC uses CRC-aided LDPC codes decoded by BP. Both adopt a mother code of rate Rm=0.25R_m=0.25, and transmit half of the mother codeword in the initial transmission (i,e,, rate 0.5). LC selects the transmitted bits according to the 5G NR LDPC rate-matching pattern [etsi38212], while MSC uses the most reliable positions in the polar reliability sequence [etsi38212]. The remaining bits of the mother code are delivered in the retransmission. TABLE I: Training parameters Parameter Value Parameter Value Training SNRs −2-2 to 22 dB Learning rate 3×10−53× 10^-5 Optimizer Adam Batch size 128 TSECT_SEC 0.001 TSLDT_SLD 0.1 VII-A3 Evaluation metrics Our evaluation captures both transmission reliability and semantic fidelity. For transmission reliability, we use sentence-level BLER: each sentence s is treated as a single block regardless of encoding method, and a block error occurs when the recovered sentence differs from the original after all processing stages. This ensures fair comparison, as computing BLER per segment for MSC would yield misleadingly low error rates. For semantic fidelity, we adopt BLEU [bleu] and ROUGE-L [rouge], which evaluate n-gram precision and longest common subsequence similarity, respectively, providing fine-grained assessments of reconstruction accuracy at the character level. In the remainder of the paper, we refer to ROUGE-L simply as ROUGE. VII-B Single Transmission Performance Comparison This subsection compares LC, MSC, MSC-SEC, and MSC-SLD. To isolate the effect of segmentation from that of semantic processing, we also evaluate LC augmented with the same fine-tuned SEC module, denoted LC-SEC. VII-B1 BLER Figure 5(a) compares the BLER performance for q=8q=8. In the low-SNR regime, both LC and MSC exhibit high BLER. LC enters its waterfall region near 11 dB and reaches BLER =10−4=10^-4 at 2.12.1 dB, whereas MSC reaches BLER =10−2=10^-2 at 2.52.5 dB. The gap reflects the reduced coding gain of short block codes at finite blocklength, as indicated by the normal approximation bound [PPV]. Adding SEC affects the two schemes differently. For LC, LC-SEC yields negligible BLER improvement, since a decoding failure of a single long codeword typically corrupts the entire sentence and leaves no reliable context for semantic reconstruction. MSC-SEC provides a 0.40.4 dB gain over MSC across all SNRs, because localized segment failures leave the surrounding segments correct for reconstruction. MSC-SLD further improves BLER, with approximate 0.80.8 dB over MSC and 0.40.4 dB over MSC-SEC, owing to bit-level WHD verification of multiple candidates. VII-B2 Semantic Fidelity BLEU and ROUGE scores are reported in Fig. 5(b) and (c). At SNR=−0.5dBSNR=-0.5~dB, MSC-SEC raises BLEU from 66 to 2828 and ROUGE from 55 to 4848 relative to MSC; MSC-SLD raises them further to 4545 and 6565, respectively. However, the SEC model only improves the semantic scores of LC slightly. The segmentation strategy of MSC-series methods leads to superior BLEU and ROUGE performance over LC at low SNRs. Figure 6: MSC-SEC performance with different code lengths in BLER, BLEU, and ROUGE. Figure 7: MSC-SLD performance with different code lengths in BLER, BLEU, and ROUGE. VII-C Impact of Code Length We compare four code configurations, including (32,16)(32,16), (64,32)(64,32), (128,64)(128,64), and (256,128)(256,128), at a fixed rate R=0.5R=0.5 to study the interplay between blocklength and semantic processing gain. Since the total sentence length is fixed at 512512 bits, varying the blocklength changes the number of segments to q=32,16,8,4q=32,16,8,4, respectively. VII-C1 MSC-SEC Performance Figure 6 demonstrates BLER and semantic fidelity for MSC-SEC across all four code lengths, as well as their gaps to LC. As shown, shorter codes yield worse BLER at every SNR, consistent with trend indicated by finite blocklength bound. SEC can improve BLER for all code lengths (as shown in Fig. 5), but only the (256,128)(256,128) code reaches BLER comparable to LC under SEC. The remaining three codes, despite the SEC gain, still fall short of the LC waterfall curve by a considerable gap. The (32,16)(32,16) code performs worst, remaining above BLER =10−2=10^-2 throughout the SNR range. The semantic metrics exhibit the opposite trend. At low SNR, shorter codes achieve higher BLEU and ROUGE. Specifically, at 0 dB, (32,16)(32,16) and (64,32)(64,32) lead (128,64)(128,64) and (256,128)(256,128) by roughly 24%24\% on both metrics. This is because each (32,16)(32,16) segment failure corrupts only 22 characters, leaving most of the sentence intact for the language model to reconstruct from, whereas a (256,128)(256,128) failure corrupts 1616 characters and removes a larger fraction of the available context. As SNR increases and segment error rates drop, longer codes overtake shorter ones in semantic fidelity as well. This is because at high SNR the error-correction capability of longer channel codes dominates and the additional gain from semantic processing becomes marginal. VII-C2 MSC-SLD Figure 8: Impact of the number of segments q on BLER at SNR =2=2 dB for different methods. Figure 7 shows MSC-SLD performance for all four code lengths. Compared to MSC-SEC in Fig. 6, SLD provides additional BLER and semantic gains across all configurations, with the improvement most significant for shorter codes. For BLER, at low SNR longer codes perform worse than shorter ones, because a longer code has fewer segments (q=4q=4 for (256,128)(256,128) versus q=32q=32 for (32,16)(32,16)), leaving SLD with less intact context to reconstruct from. At high SNR, shorter codes exhibit higher BLER, as the channel code’s own error-correction capability becomes the dominant factor and longer codes benefit from their larger minimum distance. The crossover occurs around 1.31.3 dB. Among all configurations, the (32,16)(32,16) code reaches BLER =10−3=10^-3 at 33 dB, which is similar to the (64,32)(64,32) code. For semantic fidelity, the advantage of shorter codes is more significant. At 0 dB, the (32,16)(32,16) code achieves BLEU =94.3=94.3 and ROUGE =97.4=97.4, compared to 8585 and 9292 for (64,32)(64,32) and 6161 and 7474 for (256,128)(256,128). At the same SNR, LC produces near-zero BLEU and ROUGE because a single long-codeword failure destroys the entire sentence. VII-C3 BLER versus Number of Segments Figure 8 plots BLER against q at a fixed SNR of 22 dB. For MSC without semantic processing, BLER grows by nearly three orders of magnitude from q=4q=4 to q=32q=32, reflecting the finite-blocklength penalty of progressively shorter codes. Adding SEC and SLD narrows this spread. MSC-SLD limits the growth to approximately one order of magnitude over the same range. The gap between MSC and MSC-SLD widens with q, indicating that the semantic processing gain scales with the number of segments and partially compensates for the reduced coding gain of shorter blocklengths. At q=4q=4, MSC-SLD approaches the LC baseline. VII-D Analytical versus Simulation Results Figure 9 compares the analytical BLER from (27) and the approximation from (28) against simulation results for MSC-SEC using the (64,32)(64,32) and (128,64)(128,64) codes. The (256,128)(256,128) code is omitted from the figure as all three curves nearly overlap, confirming that both expressions are tight when the number of segments q is small. For the (128,64)(128,64) code with q=8q=8, (27) closely matches the simulation, validating the independence assumption underlying the term [Prec(qe)]qe[P_rec(q_e)]^q_e. As the code length decreases to (64,32)(64,32) with q=16q=16, a noticeable gap emerges. Eq. (27) underestimates the simulated BLER by approximately 0.2 dB. This is because the independence assumption treats the recovery outcomes of individual erroneous segments as mutually independent, each succeeding with probability Prec(qe)P_rec(q_e). In practice, however, when multiple segments fail simultaneously, they mutually deprive each other of contextual information. The joint recovery probability is therefore lower than the product [Prec(qe)]qe[P_rec(q_e)]^q_e, and this correlation effect becomes more pronounced as q increases and simultaneous failures become more frequent. Figure 9: Comparison of analytical BLER and simulated BLER for MSC-SEC. The approximation (28), which replaces Prec(qe)P_rec(q_e) with a constant η, overestimates the simulated BLER consistently. This is because Prec(qe)P_rec(q_e) decreases monotonically with qeq_e, and η, as a weighted average over all qeq_e, underestimates recovery for the small-qeq_e terms that dominate the binomial sum at moderate PeOSDP_e^OSD. Despite these gaps, both expressions track the simulated BLER trend closely across all code lengths and serve as practical bounds for code parameter selection. VII-E Effect of Fine-Tuning The SEC and SLD modules rely on a fine-tuned BART model. A natural question is whether fine-tuning is necessary, or whether the pretrained BART-base already possesses sufficient language knowledge to perform the reconstruction. In this subsection, we replace the fine-tuned BART with the pretrained BART-base while keeping the rest of the pipeline. We test on the (128,64)(128,64) code. As shown in Fig. 10, the pretrained models provide negligible improvement over the baseline MSC. This is because the generic denoising patterns learned during pretraining (e.g., token masking, deletion, and shuffling) differ substantially from the structured errors introduced by channel decoding. In contrast, the fine-tuned models achieve significant gains. SEC-Finetune provides approximately 0.4 dB improvement over MSC, and SLD-Finetune extends this to over 0.8 dB. These results confirm that fine-tuning on channel-specific error patterns is essential for the proposed framework. Figure 10: BLER comparison of pretrained and fine-tuned SEC/SLD models with (128,64)(128,64) MSC. VII-F Retransmission Performance Analysis We evaluate HARQ performance with mother codes (256,64)C(256,64), (128,32)C(128,32), and (64,16)C(64,16) at mother-code rate Rm=1/4R_m=1/4 and first-transmission rate Rt=1/2R_t=1/2. To ensure a fair comparison across configurations, the retransmission budget is fixed at 128128 parity bits per sentence across all three codes. This corresponds to retransmitting at most 11 segment for q=8q=8, 22 segments for q=16q=16, and 44 segments for q=32q=32. Three schemes are compared: (i) MSC-HARQ, which is the IR-HARQ baseline without semantic processing. It re-transmits segments randomly selected from the error set identified by PSEC,iP_SEC,i in Section IV-A; (i) MSC-SLD-SHARQ, which applies SLD in both transmission rounds and prioritizes retransmission by the confidence score PSLD,iP_SLD,i. (i) LC-HARQ, which encodes the entire sentence as a single long LDPC codeword and retransmits 128128 additional parity bits via IR-HARQ. Figure 11: Retransmission performance comparison of MSC-HARQ, MSC-SLD-SHARQ, and LC-HARQ in BLER and ROUGE. VII-F1 BLER Performance As shown in Fig. 11 (a), MSC-HARQ suffers high BLER in the low-SNR regime, with the gap between code lengths widening as the SNR increases in accordance with the finite-blocklength bound. MSC-SLD-SHARQ achieves substantially lower BLER across the entire SNR range. The (256,64)(256,64) code reaches a BLER of 0.0460.046 at −0.5-0.5 dB; MSC-HARQ requires approximately 2.12.1 dB additional SNR to reach the same BLER. At high SNR, MSC-SLD-SHARQ with the (256,64)(256,64) code retains a small advantage over LC-HARQ down to BLER =10−4=10^-4. Under MSC-SLD-SHARQ, the BLER gap between (128,32)(128,32) and (64,16)(64,16) is much smaller than under MSC-HARQ. Shorter codes produce more segments, so retransmitting a few selected segments together with SLD recovery over the remaining context corrects a comparable fraction of errors. Both shorter codes maintain a BLER advantage over LC-HARQ up to 1.5 dB. Compared to single-transmission MSC-SLD as shown in Fig. 7, MSC-SLD-SHARQ provides an additional gain of approximately 1.5 dB at the same target BLER. VII-F2 Semantic Performance Figure 11 (b) shows the ROUGE scores. Under MSC-HARQ, the three code lengths achieve similar ROUGE performance, with longer codes maintaining only a marginal lead. Although shorter codes suffer higher BLER due to weaker per-segment error correction, the retransmission resolves the most corrupted segments, and the remaining errors are distributed across many small segments, yielding comparable readability across code lengths. Under MSC-SLD-SHARQ, shorter codes achieve markedly higher semantic scores. At −0.5-0.5 dB, the (64,16)(64,16) code attains ROUGE = 99.4=\,99.4, compared to 94.894.8 for (128,32)(128,32) and 76.176.1 for (256,64)(256,64), while all MSC-HARQ codes score approximately 4040 and LC-HARQ drops to 5.45.4. Fine-grained segmentation localizes each failure to a few characters, so more context remains for language-model reconstruction than when a few large segments are missing. The (64,16)(64,16) code maintains ROUGE >> 9999 across all evaluated SNRs. LC-HARQ exhibits highly unstable semantic performance. A successful LC decoding yields a perfect sentence, whereas a failure corrupts the entire output, leaving no partial context for semantic recovery. This produces near-zero ROUGE at low SNR even with retransmission. Figure 12: Impact of retransmission strategy, confidence-guided (MSC-SLD-SHARQ) versus random selection (MSC-SLD-HARQ). VII-F3 Retransmission Strategy Analysis We compare two segment-selection strategies for retransmission: MSC-SLD-SHARQ, which retransmits the segments with the lowest success probability PSLD,iP_SLD,i, and its random-selection counterpart MSC-SLD-HARQ, which selects segments uniformly at random from the SLD error set harqS_harq. Both apply SLD in transmission rounds; they differ only in the retransmission priority. As shown in Fig. 12, the confidence-guided strategy consistently outperforms random selection. MSC-SLD-SHARQ leads by 0.20.2 dB for the (64,16)(64,16) code and by 1.11.1 dB for the (256,64)(256,64) code. This trend reflects the distribution of PSLD,iP_SLD,i across erroneous segments. For short codes with large q, per-segment BLER is high and the values of PSLD,iP_SLD,i are relatively uniform, so random selection has a high probability of hitting a near-worst segment. For longer codes with small q, failures are few but their severity varies widely, so random selection is likely to miss the most damaging segment. The confidence-guided strategy targets the least reliable segment directly, yielding a larger marginal gain per retransmitted segment as q decreases. VII-G Latency Analysis Table IV presents the per-sentence decoding latency of each configuration. LC requires 16301630 ms per sentence with 8080 BP iterations, which is prohibitive for latency-sensitive applications. MSC can decode the q segments in parallel. The per-sentence channel-decoding latency decreases with q, showing 160160, 9090, and 5353 ms for q=8q=8, 1616, and 3232, respectively. The growth with segment length is expected, since a longer segment requires a higher OSD order m=⌈dmin/4⌉m= d_ /4 , and the OSD complexity scales as O(km+2)O(k^m+2). The (256,128)(256,128) configuration (q=4q=4) is omitted because OSD at order m=8m=8 is computationally prohibitive. The semantic modules add a per-sentence cost that is independent of q, since each runs once on the full sentence, which are 6363 ms for SEC and 230230 ms for SLD. Even with the semantic overhead included, MSC remains substantially faster than LC. At q=16q=16, MSC-SEC and MSC-SLD take 153153 ms and 383383 ms per sentence, corresponding to 90%90\% and 76%76\% latency reductions over LC, respectively. Combined with the BLER and semantic-fidelity results in Sections VII-B, this confirms that the proposed framework improves reliability while retaining a latency profile suitable for short-packet transmission. We note that BP decoding is itself amenable to parallelization, where all node updates can be executed concurrently under a flooding schedule. In this work we report the latency of a standard Sionna BP implementation. The intra-decoder parallelism of BP applies to one long codeword, whereas MSC parallelism is segment-level. The segment-level parallelism remains complementary to the intra-decoder BP parallelism. TABLE IV: Latency breakdown for each decoding scheme (per sentence). Scheme Time(ms) Scheme Time(ms) LC 1630 MSC (q=8q=8) 160 MSC (q=32q=32) 53 MSC (q=16q=16) 90 MSC-SEC 63 MSC-SLD 230 VIII Conclusion This paper proposed a receiver-side framework that integrates a pretrained language model into the decoding of short block codes while preserving the source–channel separation architecture. The key insight is that transmitting a sentence as multiple short codewords localizes each channel-decoding failure to a small segment, leaving the surrounding segments to serve as context for language-model-based recovery. Building on this idea, the proposed semantic error correction (SEC), semantic list decoding (SLD), and semantic hybrid automatic repeat request (SHARQ) modules couple language-model inference with bit-level channel reliability through re-encoding, and replace CRC-based error detection with a joint semantic–channel confidence score. The resulting framework attains the BLER of a long-code baseline at a fraction of the decoding latency, while maintaining high semantic fidelity even in SNR regimes where the long code fails catastrophically. References