acceptodds
Under review as a conference paper at ICLR 2027

Neural Decoding with Redundant and Reliability-Conditioned Dual Relations

Abstract

Neural decoders for linear codes typically treat the supplied parity-check matrix as a fixed structural description, even though a code admits many algebraically equivalent full-rank bases of the same dual space. We show that this choice is not neutral for finite neural decoders: equivalent parity-check bases can change bit-error rate (BER) by more than under matched code, rank, row space, architecture, and parameter count, with a residual gap remaining even under an exact row-weight-matched control. We then move beyond a single basis by exposing a rank-complete vocabulary of redundant dual relations and conditioning each relation on a normalized log soft-parity confidence derived from the current observation. Across Gallager LDPC, BCH, and MacKay LDPC, moving beyond repeated native parity coordinates to redundant dual-relation representations consistently improves a fixed CrossMPT backbone, while the benefit of particular relation sets is code dependent. Relation-level reliability provides an additional code-dependent gain and remains effective in a larger-blocklength replication. On MacKay LDPC, reassigning the same per-frame reliability values to incorrect equal-weight relation identities increases BER by roughly – across 3–5 dB, and paired rescue–harm analysis shows that reliability conditioning more often repairs than introduces frame errors. Together, these results show that neural decoding depends not only on which parity relations are exposed, but also on how their observation-dependent reliability is represented to the decoder.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
neural decoding, error-correcting codes, parity-check matrices, dual codes, redundant parity relations, reliability conditioning, message-passing transformers

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_U3TuOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper systematically investigates how different parity-check matrix representations affect neural decoding performance. The authors first demonstrate experimentally that algebraically equivalent parity-check matrices can lead to different neural decoding performance. They then propose using redundant dual parity-check relations and introducing observation-dependent reliability information for each relation. The paper conducts extensive controlled experiments, primarily based on CrossMPT.

I believe this research question is meaningful, and the experimental analysis is conducted carefully.

Critical strengths
  1. Investigating the impact of different equivalent parity-check matrices on the performance of Transformer-based decoders is an important research direction. Previous works, such as MM-ECCT [1], have also explored related issues.

  2. The experimental analysis is systematic and progressive. Through row-weight matching, NativeRepeat, Random-WM, and reliability-shuffling experiments, the authors attempt to distinguish different factors affecting decoding performance. The experimental design is relatively rigorous.

Critical weaknesses
  1. The contributions of this paper are primarily empirical rather than algorithmic. The experiments demonstrate that the specific representation of a parity-check matrix affects neural decoding performance. However, the paper does not establish a general principle for determining which parity-check matrix representations are more suitable for neural decoders. For example, the large performance differences between equivalent parity-check matrices are partly attributable to variations in graph density, while the remaining performance differences become considerably smaller after controlling for row weights. In fact, a similar observation was already implicit in MM-ECCT. Therefore, the paper mainly identifies and analyzes the sensitivity of neural decoders to parity-check representations, but does not provide a clear answer to how better representations can be systematically constructed.

  2. The proposed relation-selection method lacks consistent performance advantages. Although the experiments show that introducing distinct redundant parity-check relations can improve decoding performance, the authors' specific selection strategy is not consistently superior. On Gallager codes, Selected and Random-WM exhibit almost no significant performance difference. On MacKay codes, Random-WM even outperforms Selected across multiple random seeds. Furthermore, on BCH codes, there is also a substantial performance gap compared with the recent plug-and-play method proposed by Xiao et al. [2].

Questions for authors

The authors' investigation of how parity-check matrix representations affect neural decoding performance is relatively systematic and clearly involves a considerable amount of work. However, the final proposed method and its performance improvements are rather limited. Moreover, some of the conclusions are relatively straightforward in the context of decoding, which makes the overall contribution of the paper insufficiently compelling.

Please refer to the major weaknesses above for the specific concerns.

References

[1] S.-J. Park, H.-Y. Kwak, S.-H. Kim, S. Kim, Y. Kim, and J.-S. No. Multiple-Masks Error Correction Code Transformer for Short Block Codes. IEEE Journal on Selected Areas in Communications, 43(7):2518–2529, 2025.

[2] S. Xiao, W. Fang, and Q. Zhang. Drop-in Circulant Structural Priors for Transformer Decoding of Cyclic Codes. Proceedings of the 43rd International Conference on Machine Learning (ICML), PMLR 306:138689–138707, 2026.

2 comments
AuthorsOpenReview ↗

Response to Reviewer U3Tu (1/2)

We thank the reviewer for separating two questions: whether neural decoders are sensitive to the parity representation, and whether we know how to construct a good one.

1. Empirical contribution; density; relation to MM-ECCT. We agree with the reviewer on the facts. Most of the dense-basis gap is explained by row density, and the residual under exact row-weight matching is modest: 1.28×1.28\times at 5 dB on BCH(31,16) (Table 1), and 1.21±0.04×1.21 \pm 0.04\times over 3–5 dB in the compact Learned(31,16) control (three seeds, identical initialization and data streams). We also agree that Multiple-Masks ECCT already implies that the choice of parity-check matrix matters. We therefore position basis sensitivity (C1) as a controlled diagnostic that motivates the method rather than as a central contribution.

On the construction principle: the method is inspired by the dual code in coding theory. Every dual codeword is a valid parity check, and classical decoders use multiple bases, redundant checks, and low-weight dual codewords because each provides a new check neighborhood (Section 4.1). In the soft-decoding view, the confidence of a relation uu, ∏i∈supp(u)tanh⁡(∣Li∣/2)\prod_{i \in \mathrm{supp}(u)} \tanh(|L_i|/2), decays with relation weight and is limited by its weakest bit. This predicts large redundancy gains where native checks are dense, and larger confidence gains where native checks are already sparse. Table 2 follows this pattern: BCH codes gain up to about 80×80\times lower BER at 6 dB from redundancy, while LDPC(121,60) and CCSDS gain little from redundancy but about 22% from ρ\rho at 5 dB.

2. The selection rule is not consistently better. We agree, and the revised paper no longer claims that it is. The evidence is mixed: on compact Gallager, Selected and Random-WM are essentially tied (0.71±0.400.71 \pm 0.40%); on MacKay with the 300k-step protocol (three seeds, five support draws), Random-WM is better by 11.85±2.3111.85 \pm 2.31%; on MacKay at reference scale (Table 3), Selected is better by 6–10%.

Relation identities can therefore change BER at a fixed budget, rank, and row-weight histogram (by roughly 6–12%), but the direction of the effect varies across protocols. Our deterministic selector does not establish a consistently superior mechanism. We state this in Sections 6.3 and 7 and identify learned, observation-adaptive, or backbone-aware selection as a key direction for future work.

The effect that holds across all evaluated settings is the gain from confidence conditioning: it appears for both relation sets, improving Random-WM by 13–16% (Table 3), while a parameter-matched placebo gives no gain (Appendix Table 8). Same-weight shuffling of ρ\rho shows that the correct assignment lowers BER by 57–96% on MacKay and 75–95% on Gallager (Appendix Table 10). Replacing repeated checks with distinct relations helps on most codes (24 of 27 points in Table 2, and for both supports on Gallager and MacKay), but not on LDPC(121,60).

AuthorsOpenReview ↗

Response to Reviewer U3Tu (2/2)

3. Gap to Xiao et al. on BCH codes. The reference-scale experiments substantially change our BCH results: on BCH(63,36), Selected+ρ\rho reaches −ln⁡(BER)=6.99/9.98/14.01-\ln(\mathrm{BER}) = 6.99/9.98/14.01 at 4/5/6 dB, versus 5.03/6.91/9.375.03/6.91/9.37 for published CrossMPT. Xiao et al.'s circulant prior exploits cyclic structure and therefore targets cyclic codes. Our relation vocabulary and confidence feature require only a parity-check matrix, and we apply them to non-cyclic LDPC, MacKay, and CCSDS codes as well. For cyclic codes, the set of low-weight dual relations is closed under cyclic shifts, so the two approaches may partly exploit the same structure; we cite Xiao et al. in Related Work and view the methods as complementary.

4. "Some conclusions are relatively straightforward." We accept that the high-level message is natural from a coding-theory viewpoint; indeed, the method is directly motivated by the dual code. Two results were not obvious to us in advance. First, at an equal number of relation tokens and equal compute, replacing repeated checks with distinct relations matters, so the gain is not simply from more tokens. Second, CrossMPT already receives every ∣yi∣|y_i|, yet explicitly aggregating them per relation still helps, while a 33-parameter placebo does not. This suggests that, at these scales, the backbone does not learn relation-level aggregation by itself.

We thank the reviewer again and are happy to provide further details.

Reviewer_ABPLOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

Transformer-based neural decoders have demonstrated competitive performance on binary linear codes by using the magnitudes of the received symbols and the syndrome of the hard decisions as a codeword-invariant representation of the channel errors. This enables training using only the all-zero codeword while generalizing to arbitrary codewords. This idea has been employed in ECCT and subsequent architectures, notably CrossMPT.

This paper builds upon CrossMPT by investigating the choice of parity-check representation supplied to the decoder. The authors first demonstrate that algebraically equivalent parity-check matrices, which define the same linear code, can lead to significantly different neural decoding performance. Motivated by this observation, they exploit the fact that linear combinations of valid parity-check equations yield additional valid parity equations. They augment the original parity-check matrix with selected redundant dual-code relations, which are incorporated as additional check-node tokens in CrossMPT.

The paper further introduces an observation-dependent reliability measure for each parity relation, computed by aggregating the received soft information over the bits participating in that relation. This reliability is incorporated into the corresponding check-node embedding. Experiments across several LDPC and BCH codes demonstrate reductions in bit-error rate (BER) from both redundant parity relations and relation-level reliability conditioning.

Critical strengths
  1. Simple and effective modification. The proposed method makes a relatively simple, interpretable modification to the CrossMPT architecture by augmenting its parity-check representation and incorporating relation-level reliability. Despite the simplicity of the approach, the experiments demonstrate substantial BER improvements across multiple code families.

  2. Good experiments and ablations. The paper provides a thorough experimental analysis to isolate the effects of parity representation, redundant relations, and reliability conditioning. In particular, the equivalent-basis experiments, row-weight-matched controls, and reliability-shuffling experiments strengthen the empirical conclusions. The paper is also clearly written and the experimental methodology is well explained.

Critical weaknesses
  1. Insufficient comparison against stronger and more relevant baselines. The paper uses CrossMPT as its backbone but does not reproduce the original CrossMPT experimental settings, which use a larger model and longer training. Consequently, the reported improvements are not sufficient to establish gains over a competitive, well-trained CrossMPT decoder.

  2. Lack of compute-matched comparisons. While the NativeRepeat baseline controls for the number of relation tokens, it is not a substitute for comparing against a stronger native CrossMPT decoder at matched computational complexity. The proposed method substantially increases the computational cost relative to native CrossMPT. It is unclear whether comparable improvements could be achieved simply by increasing the hidden dimension or number of layers of the original decoder. Without such comparisons, it is difficult to establish whether augmenting parity-check relations is a more effective use of computational resources than increasing model capacity.

Questions for authors
  1. Comparison with CrossMPT: Could the authors clarify the differences in architecture and training settings compared to the original CrossMPT paper? For example, the original CrossMPT reports BERs of 3.46×10−43.46\times10^{-4} and 7.73×10−67.73\times10^{-6} for MacKay LDPC(96,48) at 4 and 5 dB, respectively, which are better than even the proposed method in Table 1. Would the proposed method still show gains under the original settings?

  2. Computational complexity: It would be helpful to include comparisons at matched computational complexity. NativeRepeat is not necessarily a substitute for increasing the capacity of the original CrossMPT. Could a larger CrossMPT achieve similar gains at the same computational cost?

  3. Generalization to other architectures: The proposed parity-check augmentation seems quite general. Have the authors considered applying it to newer architectures such as EfficientMPT (ICLR 2026), which scales to much longer blocklengths (up to n=1920n=1920 and beyond)? It would be interesting to see whether the improvements persist in these settings.

  4. Comparison with related work: Could the authors consider comparisons with other relevant baselines, such as Multiple-Masks ECCT (Park et al., 2025), which is already cited? CrossED (2025), which uses multiple parity-check matrices with CrossMPT, also seems particularly relevant. Even comparisons in the appendix would help establish the contribution relative to existing methods.

I would be willing to increase score if my concerns are addressed. The paper has good ideas, but there's still room to improve imo.

2 comments
AuthorsOpenReview ↗

Response to Reviewer ABPL (1/2)

We thank the reviewer for the positive assessment and for stating concrete conditions for re-evaluation.

1. Comparison with CrossMPT under the original settings. In the original submission, Gallager and BCH used a compact two-layer, d=32d=32 CrossMPT, and MacKay used the CrossMPT architecture with a shortened 300k-step schedule. The revised Table 2 uses the reference six-layer, d=128d=128, eight-head CrossMPT on nine standard codes. Our Native is within 0.25 nats of the published CrossMPT scores at all 27 code–SNR points.

BER on MacKay(96,48):

Decoder4 dB5 dB6 dB
CrossMPT (published)3.46×10−43.46\times10^{-4}7.73×10−67.73\times10^{-6}1.82×10−71.82\times10^{-7}
Native (ours)3.87×10−43.87\times10^{-4}8.00×10−68.00\times10^{-6}1.82×10−71.82\times10^{-7}
Selected+ρ\rho (ours)2.41×10−42.41\times10^{-4}4.43×10−64.43\times10^{-6}1.21×10−71.21\times10^{-7}

So the gains persist under the reference settings: Selected+ρ\rho lowers BER relative to our Native by 38%, 45%, and 34% at 4/5/6 dB (30%, 43%, and 34% relative to the published values, although that comparison is not paired). On BCH(63,36), Selected+ρ\rho achieves about 21×21\times lower BER than our Native at 5 dB.

2. Compute-matched comparison. We agree that NativeRepeat does not control for capacity. Appendix Table 5 adds Native-Wide: native checks, six layers, and width d=192/168/152d = 192/168/152 on BCH(63,36)/MacKay(96,48)/LDPC(121,60), with analytic MACs within 3.04% of Selected+ρ\rho (d=128d=128, M=128M=128). Selected+ρ\rho is better at all nine points, but the source of the advantage differs by code, as Section 6.4 now states:

  • BCH(63,36): Selected alone exceeds Native-Wide by 1.78–4.14 nats, so width does not substitute for the added relations.
  • MacKay(96,48): Selected alone is better at 4 and 5 dB but not at 6 dB.
  • LDPC(121,60): Native-Wide beats Selected without ρ\rho; the advantage at matched MACs comes from the confidence pathway, which costs only d+1d+1 parameters.

We varied width at fixed depth. We also report measured cost (Table 7): Selected+ρ\rho uses 1.39–3.59$\times$ the MACs of Native, with +2–8% latency at batch 1 and +36–100% at batch 128. This cost is acknowledged in Section 7.

AuthorsOpenReview ↗

Response to Reviewer ABPL (2/2)

3. Other architectures and longer blocklengths. Table 4 applies the representation to EfficientMPT on BCH(63,36) and to HyperBP on BCH(63,51). At 5 dB, Selected lowers BER relative to NativeRepeat by 93.5% (EfficientMPT) and 53.7% (HyperBP), and confidence conditioning gives a further 3.7% and 4.0%. HyperBP has no relation tokens, so we designed a backbone-specific mechanism in which relation reliability enters through FiLM modulation of the hypernetwork's first-layer edge weights. This interface outperformed additive and gating alternatives (Appendix A.3), suggesting that relation-level information should be introduced in a form matched to each decoder, and that backbone-aware relation selection and conditioning are natural extensions. The HyperBP study uses 12 native and 12 added relations.

We have not evaluated long blocklengths such as the n=1920n=1920 settings of EfficientMPT, and we list this as a limitation (Section 7). The longest code we test is Gallager(252,128) with the compact backbone, where the same ladder holds over three seeds: redundancy lowers BER by 21%, confidence by a further 34%, and the combination by 48% (Appendix Table 16). Candidate generation itself scales easily, since pairwise combinations number O(r2)O(r^2); how to set the token budget MM and select relations as nn grows is an open question for future work.

4. Multiple-Masks ECCT and CrossED. Both are now discussed in Related Work. Multiple-Masks ECCT assigns masks derived from different parity-check matrices to different attention heads, and CrossED combines CrossMPT decoders operating on different parity-check matrices; both expose alternative full parity-check matrices. Our approach keeps a single decoder, adds distinct dual relations as extra relation tokens, and attaches a per-relation confidence to each token. The confidence feature is orthogonal to both methods and could be added to either. Table 2 uses the standard benchmark codes and the −ln⁡(BER)-\ln(\mathrm{BER}) metric common to this line of work, which allows direct comparison with published results; a matched head-to-head rerun was not feasible within this revision.

We hope these additions address the reviewer's conditions, and we would be glad to clarify anything further.

Reviewer_xePkOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a pluggable component for CrossMPT that achieves lower BER in the reported experiments. The component uses a redundant parity-check matrix to facilitate information flow through attention, with further improvements from per-check reliability scores.

Critical strengths
  1. This paper offers a new perspective on neural decoding by adjusting the parity-check matrix. This approach, together with per-check reliability information, is a novel idea and may offer a path toward better performance. The proposed component can be integrated into CrossMPT and potentially other models based on parity-check matrices.
Critical weaknesses
  1. The method’s novelty lies only in the introduction of redundant check relations, but no deep intuition or theoretical insights are provided.

  2. The experiments demonstrate improvements within the tested CrossMPT configurations, but leave unclear whether these reflect a general representation principle or compensate for limited backbone capacity and suboptimal relation selection. Please evaluate the proposed features with full-sized and compute-matched backbones on the same codes, include Random-WM + reliability, and compare classical BP under the same parity-representation interventions.

Questions for authors
  1. To demonstrate the practical significance of this work, please add comparisons with classical non-neural decoders, such as BP decoders, preferably also using the modified parity-check matrices.

  2. According to the appendix, the MacKay code uses the same CrossMPT backbone hyperparameters as in the original paper. However, the BER reported for CrossMPT in this work differs substantially from the original results, as shown in Table 1. Please identify the cause of these differences. If they arise from changes to the training procedure or model configuration, please explain why those changes were made.

  3. Please provide either an error analysis of the results in Table 1 or an expanded table covering more linear codes for comparison. This request also applies to the other results and conclusions.

  4. In Table 8, increasing the relation count from 48 to 128 (2.67×) increases MACs from 4.74M to 8.68M (1.83×), while peak memory usage barely changes. Please provide further analysis of this behavior.

  5. Do the gains from redundancy and reliability persist on the same codes with a full-sized CrossMPT, and when compared against a model using native checks with comparable computation?

  6. The paper extensively uses the Learned(31,16) code, but it is unclear what this refers to or where its definition and relevant resources can be found.

2 comments
AuthorsOpenReview ↗

Response to Reviewer xePk (1/2)

We thank the reviewer for the concrete requests, which directly shaped the revision.

W1. Intuition / theoretical motivation. The method is inspired by the role of the dual code in coding theory. Every codeword of the dual code C⊥\mathcal{C}^{\perp} is a valid parity check, and a parity-check matrix is only one basis of C⊥\mathcal{C}^{\perp}. Classical decoders exploit this freedom through multiple bases, redundant checks, and low-weight dual codewords (Hehn et al., 2010; Santi et al., 2018; Bossert, 2020), because each additional dual codeword provides a new check neighborhood without changing the code. We transfer this idea to neural decoding by exposing additional dual codewords as relation tokens (new paragraph in Section 4.1).

The soft-decoding view also indicates when this should help. Under the standard independent-bit approximation, the confidence carried by a relation uu is ∏i∈supp(u)tanh⁡(∣Li∣/2)\prod_{i \in \mathrm{supp}(u)} \tanh(|L_i|/2), which decays with relation weight and is limited by the least reliable bit. Distinct relations provide alternative neighborhoods that may avoid unreliable bits, whereas repeated copies of the same check cannot. ρu\rho_u is a length-normalized proxy for the log of this quantity, so it indicates which exposed relations to trust for the current frame. This is consistent with the measured pattern: the largest redundancy gains occur on BCH codes, whose native parity-check matrices are dense (about 80×80\times lower BER on BCH(63,36) at 6 dB), whereas on sparse LDPC/CCSDS matrices the gain comes more from ρ\rho (about 22% at 5 dB on LDPC(121,60) and CCSDS(128,64)). We present this as a motivation rather than a theorem.

W2 / Q5. Full-size and compute-matched backbones. Table 2 uses the six-layer, d=128d=128 CrossMPT on the same MacKay(96,48) and BCH(63,36) codes as the original submission, plus seven further codes. Native is within 0.25 nats of published CrossMPT at all 27 points, and Selected+ρ\rho improves over NativeRepeat at all 27 points.

Native-Wide (Appendix Table 5) widens the native model to d=192/168/152d = 192/168/152 so that analytic MACs are within 3.04% of Selected+ρ\rho. Selected+ρ\rho is better at all nine points, but the source differs by code (Section 6.4). On BCH(63,36), Selected alone beats Native-Wide by 1.78–4.14 nats. On MacKay, Selected alone is better at 4–5 dB but not at 6 dB. On LDPC(121,60), Native-Wide beats Selected without ρ\rho, so the advantage comes from ρ\rho. Width was varied at fixed depth.

Relation selection. We agree that our selector is not necessarily optimal. Relation identities can change BER under the same weight-matched budget (by roughly 6–12%), but the direction varies across protocols, so the paper does not establish a superior selection mechanism and states this as future work (Sections 6.3 and 7). Our claims do not rely on an optimal selector. On Gallager and MacKay, distinct relations improve over repeated checks for both Selected and Random-WM supports, and ρ\rho improves both: Table 3 shows ρ\rho lowering Random-WM BER by 16.0%, 15.1%, and 12.9% at 4/5/6 dB.

AuthorsOpenReview ↗

Response to Reviewer xePk (2/2)

Q1. Classical BP. We agree this is an informative comparison. It is not included in this revision, and we list it explicitly as a limitation (Section 7). Classical precedents for redundant parity checks in BP (multiple-bases BP, minimum-weight dual checks) are discussed in Related Work and motivate our design.

Q2. MacKay discrepancy. In the original submission, the MacKay architecture matched CrossMPT (six layers, d=128d=128, eight heads). The gap came from the training protocol: 300k steps with a 4 dB validation-selected checkpoint, versus CrossMPT's 1,000 epochs of 1,000 minibatches. In the revised Table 2, our Native reaches BER 3.87×10−43.87\times10^{-4} / 8.00×10−68.00\times10^{-6} at 4/5 dB versus 3.46×10−43.46\times10^{-4} / 7.73×10−67.73\times10^{-6} published (within 0.11 nats), and Selected+ρ\rho reaches 2.41×10−42.41\times10^{-4} / 4.43×10−64.43\times10^{-6}. The 300k-step results are kept in Appendix Table 13 as a separate protocol.

Q3. Error analysis / more codes. We followed the second option and expanded the benchmark to nine codes (Table 2) plus three additional codes (Appendix Table 6). The three-seed compact diagnostics with seed-wise standard deviations are kept in Appendix B. We do not report seed-level variance for the reference-scale benchmark and state this in Section 7. We therefore treat small increments (e.g., below 0.04 nats at some BCH and Polar points) with caution and base our conclusions on the larger effects.

Q4. MACs vs. relation count, and memory. CrossMPT cost contains terms independent of MM (variable-node-side computation) and terms that grow with MM (check-node-side computation and VN–CN cross-attention). A two-point fit to the compact Gallager profile, MAC(M)≈C+αM\mathrm{MAC}(M) \approx C + \alpha M, gives C≈2.38C \approx 2.38M MACs and α≈0.049\alpha \approx 0.049M MACs per relation. About half of the Native arithmetic therefore does not scale with MM, so a 2.67×2.67\times increase in MM yields a 1.83×1.83\times increase in MACs. The batch-1 peak memory (about 18 MiB) is far larger than the parameters (about 0.2 MiB); extrapolating the two measurements to M=0M=0 leaves about 17.5 MiB, so most of the batch-1 allocation does not scale with MM. At throughput-relevant batch sizes the MM-dependent cost becomes visible: Table 7 reports +36% to +100% latency at batch 128 for Selected+ρ\rho versus Native. We acknowledge this inference cost in Section 7.

Q6. Learned(31,16). Learned(31,16) is a fixed (31,16) binary linear code with a 15×3115\times31 parity-check matrix, used only in the compact diagnostics; it is distinct from BCH(31,16). Appendix B now states this definition. To remove the ambiguity, the main-text basis experiment uses the standard BCH(31,16) code (Table 1). We will release the full Learned(31,16) parity-check matrix together with the code.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of the revision

Summary of the revision

We thank all reviewers for their constructive feedback. Revised parts are highlighted in blue in the revised PDF. The main changes are:

  1. Reference-scale benchmark (Table 2). Nine standard codes (MacKay, four BCH, two LDPC, Polar, CCSDS) with the six-layer, d=128d=128 CrossMPT, reported as −ln⁡(BER)-\ln(\mathrm{BER}) at 4/5/6 dB. Our Native configuration is within 0.25 nats of the published CrossMPT scores at all 27 code–SNR points, and Selected+ρ\rho improves over NativeRepeat (same relation-token budget, M=128M=128) at all 27 points.
  2. Compute-matched control (Appendix Table 5). A wider native CrossMPT (Native-Wide) whose analytic MACs are within 3.04% of Selected+ρ\rho.
  3. Selection vs. confidence (Table 3). Selected and weight-matched random relations (Random-WM), each with and without ρ\rho.
  4. Other backbones (Table 4). EfficientMPT and HyperBP, including a HyperBP-specific mechanism for injecting relation reliability.
  5. Basis sensitivity on a standard code (Table 1). Native, dense, and row-weight-matched bases of BCH(31,16).
  6. Motivation, limitations, and future work. A coding-theoretic motivation paragraph (Section 4.1) and an explicit Limitations paragraph (Section 7).
  7. Compact multi-seed diagnostics (Appendix B). The three-seed paired experiments from the original submission (capacity placebo, aggregation ablation, same-weight shuffle, rescue–harm analysis, Gallager(252,128)) are kept and labeled with their architectures and protocols; Learned(31,16) is now defined there.

Scope of claims. We claim that (i) at a fixed relation-token budget, distinct valid dual relations are a better use of the budget than repeated native checks on most evaluated codes (Selected beats NativeRepeat at 24 of 27 points in Table 2; LDPC(121,60) is the exception), with gains largest for BCH codes; and (ii) a relation-level confidence feature, which adds only d+1d+1 parameters, improves decoding in every evaluated setting, across relation sets and backbones.

Our results also show that relation identities can change BER at a fixed budget, rank, and row-weight histogram (by roughly 6–12%), although the direction of this effect varies across protocols. The paper therefore does not establish a consistently superior selection mechanism. Our deterministic selector is one reproducible choice, and we identify relation selection (learned, observation-adaptive, or backbone-aware) as a key direction for future work. For HyperBP, which has no relation tokens, we designed a backbone-specific FiLM-based mechanism, illustrating that relation-level information should be introduced in a form matched to the decoder.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.