ResearchCoding theoryGSI-R-0010 · Note · Correction

In Table 4 of arXiv:2607.04716v1 on 5G NR LDPC sub-codes, d(C′(E[4], 48)) is 5, not 6, and we compute d(C(E[4], 192)) = 10, not 8.

C(E[4], q) is the binary length-26q code whose checks are the first 4 rows of base graph 1 of TS 38.212 [1], lifted at lifting size q by circulants shifted right by q's lifting-set values. C′(E[4], q) is its puncturing in the first 2q positions. Minimum distances: d(C′(E[4], 48)) = 5, d(C(E[4], 192)) = 10, d(C(E[4], 384)) = 11.

Before this work
Table 4 of Danilko, Mogilnykh and Tikhomolov [2] (arXiv:2607.04716v1, 6 July 2026; no later version was listed on 15 November 2026) gives d(C′(E[4], 48)) = 6 and d(C(E[4], 192)) = 8, and for C(E[4], 384) a lower bound 8 and an upper bound 14.
Evidence
One engine. Upper bounds, and d(C′(E[4], 48)) ≥ 5, are checked by 2 scripts. One program of ours gives the other lower bounds, and a second, written separately, also those for C(E[4], 192), C′(E[4], 192) and C(E[4], 384); both use the same prepared inputs and matrix builder. No one outside the lab has reviewed the lower bounds.
What you can check
One half: every upper bound, and the lower bound for C′(E[4], 48). Run check.py and check_table.py on the files listed below (Python 3, no packages, under a second each); no other lower bound can be checked this way.
Not established
The lower bounds d(C(E[4], 192)) ≥ 10, d(C′(E[4], 192)) ≥ 9, d(C(E[4], 384)) ≥ 11 and those of the 860 values. They rest on exhaustive computations without a certificate.
Method
Not published.

What was known

Danilko, Mogilnykh and Tikhomolov [2] write C(ℰ[4], q) for C(E[4], q). Their headline code C′(E[6], 384), of length 9984 and dimension 8448, has minimum distance d listed as 8 to 14 (p. 3). The KAIST CoCoA Lab database [3] lists minimum-distance codewords of 5G NR LDPC codes; we claim no priority over any code it lists.

The result

Upper bounds

C(E[4], 48), C(E[4], 192) and C(E[4], 384) have words of weight 6, 10 and 11 (in the script below), each with 1 position among the first 2q; hence d(C′(E[4], 48)) ≤ 5, d(C(E[4], 192)) ≤ 10, d(C′(E[4], 192)) ≤ 9 and d(C(E[4], 384)) ≤ 11.

Lower bounds

d(C′(E[4], 48)) ≥ 5 follows from Table 3 and Theorem 3 of [2] (d(C′(E[4], 24)) = 5 and d(C′(E[4], 24)) ≤ d(C′(E[4], 48))); the script below computes it. d(C(E[4], 192)) ≥ 10, d(C′(E[4], 192)) ≥ 9 and d(C(E[4], 384)) ≥ 11 are exhaustive computations by programs of ours.

CodeStudy [2]Ours
C′(E[4], 48)65
C(E[4], 192)810
C′(E[4], 192)7 to 89
C(E[4], 384)8 to 1411
C′(E[6], 384)8 to 1411 to 13
Values in Table 4 of [2], and in its abstract for C′(E[6], 384), against ours.

For the headline code C′(E[6], 384), 11 ≤ d ≤ 13: the upper bound is a word of C(E[6], 384) of weight 13 with no position among the first 768 (file and last output line below); the lower bound is d(C′(E[5], 384)) = 11, from one program of ours, with eq. (7) of [2].

We computed d for 860 sub-codes of the NR base graphs, each with an explicit word of that weight (file below); our values for C(E[4], q) equal those of [2] at q = 3, 6, 12, 24, 48, 96.

Sub-codeRows LLifting sizes qCodesLengthLargest d
Base graph 14 to 9all 51306(22 + L)q ≤ 11,90418 (L = 9; q = 288, 352, 384)
Base graph 1, first 2q positions deleted445 of 514524q ≤ 9,21611 (q = 320, 352)
Base graph 24 to 12all 51459(10 + L)q ≤ 8,44829 (L = 12; q = 208, 240, 256, 320, 352)
Base graph 2, first 2q positions deleted450 of 515012q ≤ 4,6088 (q = 104, 160, 208, 240, 288, 320, 352)
L is the number of base-graph rows, taken with the first 22 + L (base graph 1) or 10 + L (base graph 2) block columns. Lengths are after deletion.

How to check it

import json

# Rows 0 to 3 of base graph 1 (TS 38.212, Table 5.3.2-2): (row i, column j, shifts V for lifting sets 0 to 7).
bg = [(i, j, v) for i, j, v in json.load(open('nr_bg.json'))['BG1'] if i < 4]

def columns(q):
    # Position j*q + t of C(E[4], q) as a bitmask over its 4q checks. Shifts are to the right, as in TS 38.212:
    # check i*q + r contains position j*q + (r + V) mod q. The other direction gives an equivalent code.
    a = q
    while a % 2 == 0:
        a //= 2
    s = [1, 3, 5, 7, 9, 11, 13, 15].index(a)          # lifting set of q (Table 5.3.2-1)
    col = [0] * (26 * q)
    for i, j, v in bg:
        for r in range(q):
            col[j * q + (r + v[s]) % q] |= 1 << (i * q + r)
    return col

def in_code(q, word):
    col, syn = columns(q), 0
    for p in word:
        syn ^= col[p]
    return syn == 0

def least_weight_up_to_4(q):
    # Least weight, if at most 4, of a nonzero word of C'(E[4], q) (first 2q positions deleted); else None.
    # A word of C' is a set of kept positions whose columns sum into the span of the 2q deleted columns.
    # Reduce the kept columns modulo that span. Two different sets of at most 2 kept positions with the
    # same reduced sum differ in a word of weight at most 4, and every such word arises this way.
    col, basis = columns(q), {}
    for x in col[:2 * q]:                              # reduced echelon basis of the deleted columns
        for p, y in basis.items():
            if x >> p & 1:
                x ^= y
        if x:
            p = x.bit_length() - 1
            for u in basis:
                if basis[u] >> p & 1:
                    basis[u] ^= x
            basis[p] = x
    def red(x):
        for p, y in basis.items():
            if x >> p & 1:
                x ^= y
        return x
    r = [red(x) for x in col[2 * q:]]
    seen, best = {}, None
    for t in [()] + [(a,) for a in range(len(r))] + [(a, b) for a in range(len(r)) for b in range(a)]:
        s = 0
        for k in t:
            s ^= r[k]
        for u in seen.get(s, ()):
            w = len(set(t) ^ set(u))
            best = w if best is None else min(best, w)
        seen.setdefault(s, []).append(t)
    return best

# Words of C(E[4], q), positions counted from 0 (position j*q + t is entry t of block j).
words = {48: [17, 96, 140, 208, 455, 1172],
         192: [192, 1425, 3984, 4125, 4422, 4547, 4589, 4614, 4739, 4742],
         384: [384, 1781, 3653, 4597, 4644, 4907, 7908, 8391, 8851, 9431, 9897]}
for q, w in words.items():
    print('q =', q, ' weight', len(w), ' codeword:', in_code(q, w), ' positions among the first 2q:',
          sum(p < 2 * q for p in w))
for q in (3, 6, 12, 24, 48):
    print('q =', q, " least weight <= 4 in C'(E[4], q):", least_weight_up_to_4(q))
check.py.
python3 check.py
q = 48  weight 6  codeword: True  positions among the first 2q: 1
q = 192  weight 10  codeword: True  positions among the first 2q: 1
q = 384  weight 11  codeword: True  positions among the first 2q: 1
q = 3  least weight <= 4 in C'(E[4], q): 2
q = 6  least weight <= 4 in C'(E[4], q): 2
q = 12  least weight <= 4 in C'(E[4], q): 3
q = 24  least weight <= 4 in C'(E[4], q): None
q = 48  least weight <= 4 in C'(E[4], q): None
Run beside nr_bg.json; about 0.3 s.

Lines 1 to 3 test the 3 words. Lines 4 to 7 agree with Table 3 of [2] at q = 3, 6, 12, 24. Line 8 (None) means C′(E[4], 48) has no word of weight ≤ 4, so d(C′(E[4], 48)) ≥ 5.

python3 check_table.py
base graph 1: 306 records, 306 pass, largest length 11904, largest d 18
base graph 1, first 2q deleted: 45 records, 45 pass, largest length 9216, largest d 11
base graph 2: 459 records, 459 pass, largest length 8448, largest d 29
base graph 2, first 2q deleted: 50 records, 50 pass, largest length 4608, largest d 8
860 of 860 records pass
722 of 722 pairs q, 2q satisfy d(q) <= d(2q) <= 2 d(q)
base graph 1, 6 rows, q = 384: word of weight 13, least position 1920 (the first 2q = 768 are deleted in the punctured code)
Run beside nr_bg.json and subcode_distances.jsonl; under a second.

check_table.py rebuilds each code from nr_bg.json, tests its word, and tests d(q) ≤ d(2q) ≤ 2d(q) (Theorems 2 and 3 of [2]) for consecutive lifting sizes of one lifting set.

nr_bg.json equals the Sionna files [4]; its base graph 1 equals Table 5.3.2-2 of TS 38.212 [1] in V17.3.0 and V18.6.0, and rows 0 to 11 of its base graph 2 equal Table 5.3.2-3 in V17.3.0.

What it changes

Table 4 of [2] fails at C′(E[4], 48). If the lower bounds hold, the upper bound 8 at q = 192 fails for C(E[4], 192) and C′(E[4], 192), and the bracket for C(E[4], 384) closes at 11.

Limits

  • Lower bounds d(C(E[4], 192)) ≥ 10, d(C′(E[4], 192)) ≥ 9, d(C(E[4], 384)) ≥ 11 and those of the 860 values rest on exhaustive computations without a certificate. A word of weight ≤ 9 in C(E[4], 192) or ≤ 10 in C(E[4], 384) refutes the first or third; a certificate, or a rerun outside the lab on other inputs, closes them.
  • C′(E[6], 384): a word of weight 11 or 12 would lower the upper bound 13; a certificate that none of weight ≤ 12 exists would raise the lower bound to 13.
  • Scope: the first L rows of the base graphs, not the full codes of the standard; no value for base graph 1 punctured at q = 10, 12, 13, 15, 20, 256 or base graph 2 punctured at q = 2.

Files

  • nr_bg.jsonbase graphs 1 and 2 as in the Sionna files [4]: entries [row, column, shifts for lifting sets 0 to 7]
  • subcode_distances.jsonlthe 860 values, one line each: base graph, rows L, lifting size q, punctured or not, length, d, and a word of weight d (positions counted from 0; in a punctured code, from the first position kept)
  • check.pythe script printed under How to check it
  • check_table.pytests every word of subcode_distances.jsonl against nr_bg.json, and d(q) ≤ d(2q) ≤ 2d(q) for consecutive lifting sizes

References

  1. [1]3GPP TS 38.212, NR; Multiplexing and channel coding, Section 5.3.2 and Tables 5.3.2-1 to 5.3.2-3, read as ETSI TS 138 212 V17.3.0 (September 2022), the version [2] cites, and V18.6.0 (April 2025). Link
  2. [2]V. R. Danilko, I. Yu. Mogilnykh, Ya. A. Tikhomolov, Minimum distances of LDPC codes in 5G standard, arXiv:2607.04716v1 (6 July 2026). Link
  3. [3]KAIST CoCoA Lab, Database of minimum-distance codewords in quasi-cyclic LDPC codes (J. Park, E. Ha, J. Ha), web page read 15 November 2026. Link
  4. [4]NVIDIA, Sionna, files 5G_bg1.csv and 5G_bg2.csv (base graphs 1 and 2 of TS 38.212), read 15 November 2026 at the head of the main branch; SHA-256 4ae766634def05dc45e4903c775a5ad7e1feb067747a644504b6d8c90d33b1ed and 4f4db6f7607446984c0b1dc6243bff4286f6fbad3a477f29d84a5e0edab523fb. Link

Cite asKishan Kumar, Minimum distances of 5G NR LDPC sub-codes, GSI-R-0010, https://generalised.si/research/5g-nr-ldpc-minimum-distances, 2026.

Published16 November 2026

History
  • Danilko, Mogilnykh and Tikhomolov post version 1 of [2].
  • This account published.

All results