ar
X
iv
:c
s/0
50
20
24
v1
[
cs
.IT
]
4 F
eb
20
05
Idempotents, Mattson-Solomon Polynomials and Binary
LDPC codes
R. Horan, C. Tjhai, M. Tomlinson, M. Ambroze and M. Ahmed
Fixed and Mobile Communications Research
University of Plymouth, PL4 8AA, United Kingdom
February 1, 2008
Abstract
We show how to construct an algorithm to search for binary idempotents which
may be used to construct binary LDPC codes. The algorithm, which allows control
of the key properties of sparseness, code rate and minimum distance, is constructed
in the Mattson-Solomon domain. Some of the new codes, found by using this
technique, are displayed.
1 Introduction and Background
The use of idempotents in the construction of cyclic error correcting codes is well es-
tablished and the resulting literature is extensive (for example, see [1], [3], [7]). The
basic building blocks for this theory are the primitive idempotents. Any cyclic code
may be described by a unique idempotent and this idempotent is a sum of primitive
idempotents. For binary cyclic codes, efficient algorithms exist for the calculation of
these primitive idempotents.
Another way of constructing idempotents in the binary case is by using cyclotomic
cosets and it was this property which was exploited by Shibuya and Sakaniwa in [4].
Their goal was to use idempotents to construct parity check matrices for LDPC codes
which have no cycles of length 4 in their factor graphs. At the heart of their technique
is a lemma which is a variation of a result used by Weldon [8], for the construction of
difference set cyclic codes. Using this lemma and a subsequent theorem, they were able
to simplify the problem of determining which of the idempotents that are constructed,
using a single cyclotomic coset, do not have cycles of length 4. They then extended this
theory to more general idempotents.
This approach to the construction of LDPC codes has the great advantage of simplic-
ity, the parity check matrices depend only upon the correct choice of cyclotomic cosets
and these are very easily calculated. However, we believe that this advantage is offset
by some fundamental weaknesses.
Whilst the absence of 4 cycles is a desirable objective in the construction of LDPC
codes it is not mandatory [5], since there are some good codes which do not have this
property. An example of such a code is included in this paper. The code rate is also an
important property of codes but, as Shibuya and Sakaniwa admit in their conclusion,
the codes which they construct in this way are “expected to have a large minimum
distance at the expense of rate”(our italics). The minimum distance of a code is a
crucial property but there is no indication in [4] of how either a single cyclotomic coset,
or combinations of more than one cyclotomic cosets, should be chosen to guarantee that
the code constructed has a large minimum distance.

In order to address the question of how to choose idempotents which will produce
good LDPC codes we propose an entirely different route. As in [4], we shall deal ex-
clusively with binary cyclic codes. Making effective use of the Mattson-Solomon poly-
nomial, we produce an algorithm which not only allows us to choose, in a systematic
way, idempotents with low weight, and therefore a correspondingly sparse parity check
matrix, but also with the desirable features that the corresponding codes have a high
code rate and a large minimum distance.
This paper is organised as follows. In section 2 we shall review the necessary the-
ory and explain how it will be used to provide an algorithm for the determination of
idempotents which may be used to construct good codes. In section 3 the design and
implementation of this algorithm is given and then, in section 4, some of the results are
displayed. Finally, in section 5, we draw our conclusions on this approach.
2 Binary Idempotents
Let F = GF (2), n be a positive integer and F be the splitting field for xn − 1 over F .
Let α ∈ F be a primitive nth root of unity and let T (x) be the polynomials in F [x] of
degree ≤ n− 1. If a(x) ∈ T (x) then the map Φ : T → T is defined by
[Φ(a)](z) =
n
∑
j=1
a(αj)zn−j (1)
and Φ(a) is the Mattson-Solomon polynomial of a (see [1]). (We use x and z for the poly-
nomial variables to distinguish between the polynomials in the domain and codomain
of Φ.) If ◦ is multiplication of polynomials mod (xn − 1) and ∗ is defined on T (z) by
the rule (
∑
aizi) ∗ (
∑
bizi) =
∑
aibizi then it is well known [1],[7], that
Φ : (T,+, ◦) → (T,+, ∗)
is an isomorphism of rings, in particular it is an isomorphism of the additive groups.
If S(x) is the subset of T (x) consisting of polynomials with coefficients in GF (2)
(binary polynomials) and E(x) is the subset of T (x) consisting of idempotents, both of
these subsets are additive subgroups of T (x). It is easy to show (see [1]) that
Φ : (S(x),+) → (E(z),+) (2)
Φ : (E(x),+) → (S(z),+) (3)
are both isomorphisms and from this it is obvious that
Φ : (S(x) ∩E(x),+) → (E(z) ∩ S(z),+) (4)
is also an isomorphism.
Suppose that u(x) is a binary idempotent which is used to construct a parity check
matrix for a cyclic code. The parity check matrix is constructed from the n-cyclic shifts
of u(x) [2], and so for the resulting code to be a LDPC code, u(x) must have low weight.
If h(x) = gcd(xn − 1, u(x)) and g(x) = (xn − 1)/h(x), then g(x) is the generator
of the cyclic code. If the generator, g(x), has degree n − k, the dimension of the code
is k and the larger the value of k, the better the code rate. Since g(x) is a divisor of
xn − 1, all of the zeros of g(x) are nth roots of unity, and there are n − k of these.

Further, gcd(g(x), h(x))=1 and xn − 1 = h(x)g(x), so that the number of distinct nth
roots of unity which are also roots of u(x) is k. The dimension of the code is therefore
the number of nth roots of unity which are also roots of u(x).
The BCH bound of the code is determined by the number of consecutive powers of
α, taken cyclically (modn), which are also roots of g(x). For the reasons outlined in
the previous paragraph, this is precisely the same as the number of consecutive powers
of α, taken cyclically (modn), which are not roots of u(x).
The important features of the code are therefore determined by:
(a) the weight of the idempotent u(x),
(b) the number of nth roots of unity which are roots of u(x),
(c) the number of consecutive powers of α which are not roots of u(x).
Take u(x) ∈ S(x) ∩ E(x) and let Φ(u) = θ be its MS polynomial. The inverse
mapping
Φ−1 : (S(z) ∩ E(z),+) → (E(z) ∩ S(x),+) (5)
is defined as follows: If A(z) = [Φ(a)](z) is the Mattson-Solomon polynomial of the
polynomial a(x) = a0 + a1x + · · ·+ anxn−1 then, for i = 0, . . . , n− 1,
ai =
1
n
A(αi) (6)
(see [1]). Let h(z) = gcd(θ(z), zn − 1) and let f(z) = (zn − 1)/h(z). The three key
properties relating to the idempotent u(x), listed above, are easily gleaned from its
Mattson-Solomon polynomial θ(z), and f(z), as follows:
2.1 The weight of u(x)
The weight of u(x) is the number of nth roots of unity which are zeros of f(z). To see
this note that f(αi) = 0 if and only if θ(αi) = 1, since idempotents take only the values
0 and 1 in F . Now u = Φ−1θ and the coefficients of u(x) = u0 + u1x + . . . + un−1xn−1
are given by
ui = θ(αi) mod 2 for i = 0, . . . n− 1 (7)
(cf equation (6)). Thus ui = 1 precisely when f(αi) = 0, giving the weight of u(x) as
the degree of the polynomial f(z).
2.2 The zeros of u(x).
From the definition of the MS polynomial, (1),
θ(z) =
n
∑
j=1
u(αj)zn−j (8)
and the number of zeros of u(x) which are roots of unity is clearly n− wt(θ(z)).

2.3 The BCH bound of the code.
The BCH bound of the code is the largest number of consecutive powers of α which are
not roots of u(x), i.e. the number of consecutive i, taken (modn), such that u(αi) = 1.
From (8), this is the largest number of consecutive non-zero coefficients in θ, taken
cyclically (mod n).
Using this information, a systematic search for idempotents can now be made in increas-
ing order of weight, with accompanying knowledge of the number of roots which are nth
roots of unity and the corresponding BCH bound. This algorithm is constructed in the
Mattson-Solomon domain.
Let the decomposition of zn − 1 into irreducible (over F = GF (2)) polynomials be
zn − 1 = f1(z)f2(z) . . . ft(z). For i = 1, . . . , t, let ki(z) = (zn − 1)/fi(z) and let θi(z)
be the associated primitive idempotent (see [1] or [7]). These are displayed below in an
array, together with other idempotents:
u1(x) θ1(z) f1(z)
u2(x) θ2(z) f2(z)
...
...
...
ut(x) θt(z) ft(z)









(9)
Here u1(x), u2(x), . . . , ut(x) are the idempotents whose Mattson-Solomon polynomials
are θ1(z), θ2(z), . . . , θt(z), respectively. Let I ⊆ {1, 2, . . . , t} and let u, θ and f be defined
as u =
∑
i∈I ui, θ =
∑
i∈I θi and f(z) =
∏
i∈I fi(z). From the properties of primitive
idempotents, if h(z) = gcd(θ(z), zn − 1) then it follows that gcd(f(z), h(z)) = 1 and
zn − 1 = f(z)h(z). The idempotent u will now have the following properties.
wt(u) =
∑
i∈I
deg(fi) , (10)
number of zeros of u = n− wt(θ) . (11)
The BCH bound is determined from θ(z) as explained in 2.3.
Since methods for finding the θi and fi are well documented (see e.g. [6]) a search
algorithm can be built around this observation to find a suitable weight idempotent
with a known number of zeros and a known BCH bound. The rows of the array (9),
are ordered by the degree of the polynomials, i.e. deg(fi) ≤ deg(fi+1) for all i, and a
search can be made in increasing order of weight. When a successful outcome has been
obtained, only at this stage is the inverse Fourier transform (MS−1) evaluated to find
the corresponding idempotent. All of the information which is required will already be
known.
3 Design and Implementation
If t denotes the number of cyclotomic cosets modulo n, the complexity of an exhaustive
search algorithm is O(2t). We reduce this search complexity by targeting the search on
the three key parameters:

3.1 Sparseness of the parity-check matrix
In [8], Weldon introduced difference-set cyclic codes. These codes have the desirable
property that the parity check equations are orthogonal on all bits and have no cycles
of length 4 in their factor graphs. A necessary condition for this is that if v(x) is the
polynomial which generates the parity check matrix then the weight of v(x) must satisfy
the inequality
wt(v(x))(wt(v(x))− 1) ≤ n , (12)
where n is the code length. Since the weights of the idempotents u(x) are related to the
degrees of the fi by (10), a reasonable bound is
∑
i⊆I
deg(fi) ≤
√
n . (13)
In practice we have gone a little beyond this limit and this has enabled us to find some
good codes which do have cycles of length 4 in their factor graph.
3.2 Code-rate
The code-rate is directly proportional to the number of roots of u(x). If we let Rmin
represent our minimum desired code-rate then, following equation (11), we can refine
our search bound to
wt(θ) ≤ (1−Rmin)n . (14)
3.3 Minimum distance
Let d be the lowest desired minimum distance and let rθ be the largest number of
consecutive non-zero coefficients, taken cyclically mod n, of θ. Then, following the
discussion of 2.3, we restrict our search algorithm to those θ for which
rθ > d (15)
We develop an efficient, but exhaustive recursive tree-search based on the above bounds.
The developed search algorithm, Algorithm 1, is initialised by setting V and index to
∅ and −1 respectively.
4 Code Example and Performance
Since the algorithm is an exhaustive search, the code construction method presented in
this paper is able to produce, in addition to new codes, many well-know cyclic codes,
for example the Difference-Set Cyclic codes and the Euclidean and Projective Geometry
codes. Some of the new codes which we have found using this technique are presented in
Table 1. All codes in Table 1, except those labelled with ∗, have orthogonal parity-check
equations.

Algorithm 1 CodeSearch(V, index, F(x), Q(z))
Input: Rmin ⇐ minimum code-rate of interest
d ⇐ lowest expected minimum distance
δ ⇐ small positive integer
F(x) ⇐ {fi(x)} ∀i ∈ I sorted in ascending order of the degree
Q(z) ⇐ {θi(z)} ∀i ∈ I
Output: CodesList contains set of codes
1: T ⇐ V
2: for
(
i=index+1; i ≤ Size (I); i++
)
do
3: Tprev ⇐ T
4: if
(
∑
∀j∈T deg(fj(x)) + deg(fi(x)) ≤
√
n + δ
)
then
5: Append i to T
6: θ(z) ⇐∑∀j∈T θj(z)
7: if
(
wt(θ(z)) ≤ (1−Rmin)n and rθ > d
)
then
8: u(x) ⇐ MS−1 (θ(z))
9: if u(x) is non-degenerate then
10: C ⇐ a cyclic code defined by u(x)
11: if
(
C /∈ CodeList
)
then
12: Add C to CodeList
13: end if
14: end if
15: end if
16: CodeSearch(T, index, F(x), Q(z))
17: end if
18: T ⇐ Tprev
19: end for

(n, k) u(x) dmin
(51,26)∗ 1+x3+x6+x12+x17+x24+x27+x34+x39+x45+x48 10
(63,44)∗ 1 + x7 + x9 + x14 + x18 + x27 + x28 + x35 + x36 +
x45 + x49 + x54 + x56
8
(93,47) 1 + x2 + x8 + x31 + x32 + x35 + x47 8
(105,53) 1 + x4 + x30 + x32 + x45 + x46 + x53 8
(117,72)∗ 1+x+x2 +x4 +x8 +x11 +x16 +x22 +x32 +x44 +
x59 + x64 + x88
12
(127,84)∗ 1+x+x2 +x4 +x8 +x16 +x32 +x55 +x59 +x64 +
x91 + x93 + x109 + x110 + x118
10
(219,101) 1 + x2 + x8 + x32 + x73 + x74 + x77 + x89 + x110 +
x128 + x137
12
(255,135) 1 + x4 + x13 + x21 + x39 + x54 + x55 + x91 + x121 +
x123 + x148 + x195
13
(255,175) 1+x+x3 +x7 +x15 +x26 +x31 +x53 +x63 +x98 +
x107 + x127 + x140 + x176 + x197 + x215
17
(341,205) 1+x29+x87+x92+x94+x114+x122+x156+x202+
x203 + x213 + x217 + x234 + x257 + x273
16
(511,199) 1+x+x3 +x7+x15+x31+x63+x82+x100+x127+
x152 + x165 + x201 + x255 + x296 + x305 + x331 + x403
19
(511,259) 1 + x31 + x42 + x93 + x115 + x217 + x240 + x261 +
x360 + x420 + x450 + x465
13
(819,435) 1 + x + x3 + x7 + x15 + x31 + x63 + x127 + x204 +
x255 + x409 + x511
13
(819,447) 1 + x + x3 + x7 + x15 + x31 + x63 + x127 + x204 +
x255 + x350 + x409 + x511 + x584 + x701
16
Table 1: Examples of the constructed codes
10-5
10-4
10-3
10-2
10-1
100
0.5 1 1.5 2 2.5 3 3.5 4
Fr
am
e
Er
ro
r R
at
e
(F
ER
)
Eb/No, dB
Cyclotomic Idempotent
Sphere-Packing-Bound
Figure 1: Frame error performance of the (127, 84) cyclic code
Throughout the paper, it is assume that the codewords are transmitted across a noisy
communication channel with BPSK modulation and at the receiving end is the modified
Belief-Propagation decoder which approximates the Maximum-Likelihood decoder [9].

Figure 1 shows the frame-error-rate (FER) performance of the (127, 84) cyclic code,
which is a code which does have cycles of length 4. Neverthless, the performance of this
code is outstanding and, at 10−3 FER, it is within 0.2dB of the sphere-packing-bound
constraint for binary transmission.
10-5
10-4
10-3
10-2
10-1
100
0.5 1 1.5 2 2.5 3 3.5 4
Fr
am
e
Er
ro
r R
at
e
(F
ER
)
Eb/No, dB
Irregular
Cyclotomic Idempotent
Sphere-Packing-Bound
Figure 2: Frame error performance of the (255, 175) codes
Figure 2 shows the performance of two (255, 175) codes, one constructed using our
method and one an irregular computer generated code. We can see that our code,
which achieves a coding gain of around 0.4dB compared to the equivalent irregular
code, performs approximately withinr 0.15dB of the sphere-packing-bound constraint
for binary transmission.
10-5
10-4
10-3
10-2
10-1
100
0.5 1 1.5 2 2.5 3 3.5 4
Fr
am
e
Er
ro
r R
at
e
(F
ER
)
Eb/No, dB
Irregular
Cyclotomic Idempotent
Sphere-Packing-Bound
Figure 3: Frame error performance of the (341, 205) codes
Our construction method can produce LDPC codes with high minimum distance and
therefore they do not suffer from error-floor. Figure 3 demonstrates the performance of
our (341, 205) code, which is inferior to the equivalent irregular code in the low signal-
to-ratio region, but the irregular code exhibits early error-floor due to its low minimum
distance.

5 Conclusions
A method of constructing binary cyclic codes from the finite-field transform (Mattson-
Solomon) domain is able to produce a large number of codes which have high minimum-
distance and code-rate. These codes have sparse parity-check matrix and thus are
applicable as LDPC codes. Due to their cyclic property these LDPC codes have n
parity-check equations instead of n−k equations as in the case of random LDPC codes.
With these extra parity-check equations to iterate with, the performance of the iterative
decoder is improved.
In designing cyclic LDPC codes of length n, our new method allows one to increase
the dmin of the code by combining additional irreducible factors of 1+zn which, in turn,
reduces the sparseness of the parity-check matrix. The ability to control the sparseness
of the parity-check matrix is a trade-off against the minimum distance of the code.
Simulation results have shown that the our cyclic codes have outstanding perfor-
mance which are superior to the equivalent irregular LDPC codes. The high dmin of
these codes ensures the absence of an early error-floor in their performance.
References
[1] F.J.MacWilliams and N.J.A.Sloane, The Theory of Error Correcting Codes, North
Holland, 1977
[2] V.S.Pless, W.C.Huffman and R.A.Brualdi, “An introduction to algebraic codes”,
in Handbook of Coding Theory, (V.S.Pless andW.C.Huffman, eds.), Elsevier, North
Holland, 1998
[3] S.Roman, Coding and Information Theory, Springer Verlag, 1992
[4] T.Shibuya and K.Sakaniwa, Construction of cyclic codes sutiable for iterative de-
coding via generating idempotents, IEICE Trans. Fundamentals , E86-A, No.4,
April 2003.
[5] T.Tian, C.Jones, J.Villasenor, and R. Wesel, Selective Avoidance of Cycles in Ir-
regular LDPC Code Construction, IEEE Transaction on Communications, August
2004
[6] J.H.van Lint, Coding Theory, Lecture Notes in Mathematics, 201, Springer-Verlag,
1971
[7] J.H.van Lint, Introduction to Coding Theory, second ed., Springer-Verlag, 1991
[8] E. J. Weldon, Difference-Set Cyclic Codes, Bell System Technical Journal, Septem-
ber (1966)
[9] C. Tjhai, E. Papagiannis, M. Tomlinson, M. Ambroze and M. Ahmed, ”Improved It-
erative Decoder for LDPC Codes with Performance Approximating to a Maximum-
Likelihood Decoder”, UK Patent Application 0409306.8