This section develops an algorithm that converts posterior probabilities derived from the channel output into a choice of interpolation points and their multiplicities. More specifically, given a reliability matrix Π, as defined in (3.1), we compute the multiplicity matrix M that serves as input to the soft interpolation step. Let Mq,n denote the set of all q × n matrices with nonnegative integer entries mi,j, and let M(C) be the finite set of all matrices in Mq,n whose cost is equal to C. Thus
M(C) , {M ∈ Mq,n : 1
In view of Theorem 9, we would like to choose M ∈ M(C) so as to maximize the score of the transmitted codeword c ∈ Cq(n, k).
As far as the decoder is concerned, the transmitted codeword may be thought of as a random vector χ = (χ1, χ2, · · · , χn). Thus SM(χ) is a random variable, and the question is: what is the best choice of a multiplicity matrix M ∈ M(C) in this probabilistic setting? We choose to compute the matrix M ∈ M(C) that directly maximizes the expected value of SM(χ).
To proceed, let us define the expected score with respect to a probability distribu-tion P (·) on the random vector χ = (χ1, χ2, · · · , χn) as follows:
where M (xj, j) denotes the entry found in the jth column of M in the row indexed by xj. It remains to specify P (·). For this purpose, we adopt the product distribution determined by the channel output (y1, y2, · · · , yn), namely
where Π is the reliability matrix defined in Eq.(3.1). It is easy to see that this would be the a posteriori distribution of χ given the channel observations.
Thus, we want to find M (Π, C) defined as follows:
M (Π, C) , argmaxM∈M(C)EP{SM(χ)}
where the expectation is taken with respect to the probability distribution P (·) in Eq.(3.5). We start with the following lemma, which gives a useful expression for the expected score.
Lemma 7 The expected score with respect to the probability distribution of (3.5) is equal to the inner product of the multiplicity matrix and the reliability matrix, namely
EP{SM(χ)} = hM, Πi
Input: Reliability matrix Π and a positive integer s,
indicating the total number of interpolation points.
Output:Multiplicity matrix M .
Initialization step: Set Π∗ := Π and M := all-zero matrix
Iteration step: Find the position (i, j) of the largest entry πi,j∗ in Π∗, and set π∗i,j := mπi,j
i,j+2
mi,j := mi,j + 1 s := s − 1
Control step: If s = 0, return M ; otherwise go to the iteration step.
Table 3.1: Algorithm A
Proof : It is easy to see that if χ is distributed according to (3.5), then Π is precisely the componentwise expected value of [χ]. The lemma now follows by linearity of expectation
EP{SM(χ)} = EP{hM, [χ]i} = hM, EP{[χ]}i = hM, Πi
We will construct M (Π, C) iteratively, starting with the all-zero matrix and increas-ing one of the entries in the matrix at each iteration. Referrincreas-ing to Lemma 5, we see that increasing mi,j from 0 to 1 increases the expected score by πi,j while increasing the cost by 1. If we require that QM(X, Y ) passes through the same point again (that is, increase mi,j from 1 to 2), then the expected score again grows by πi,j, but now we have to pay two additional linear constraints. In general, increasing mi,j from a to a + 1 always in-creases the expected score by πi,j while introducing a + 1 additional constraints. These observations lead to Algorithm A, which greedily maximizes the ratio of the increase in the expected score to the increase in cost at each iteration.
Let M(Π, s) denote the multiplicity matrix produced by Algorithm A for a given reliability matrix Π and a given number of interpolation points s. The following theorem shows that this matrix is optimal.
Theorem 10 The matrix M(Π, s) maximizes the expected score among all matrices in
Mq,n with the same cost. That is, if C is the cost of M(Π, s), then
M(Π, s) = argmaxM∈M(C)hM, Πi
Proof : With each position (i, j) in the reliability matrix Π, we associate an infinite sequence of rectangles Bi,j,1, Bi,j,2, · · · indexed by the positive integers. Let B denote the set of all such rectangles. For each rectangle Bi,j,l ∈ B, we define its length(Bi,j,l) = l , height(Bi,j,l) = πi,j/l, and
area(Bi,j,l) = length(Bi,j,l) · height(Bi,j,l) = πi,j
For a multiplicity matrix M ∈ Mq,n, we define the corresponding set of rectangles
ϑ(M ) , {Bi,j,l : 1 6 i 6 q, 1 6 j 6 n, 1 6 l 6 mi,j}
Note that the number of rectangles in ϑ(M ) is Pq i=1
Pn
j=1mi,j which is precisely the total number of interpolation points imposed by the multiplicity matrix M . Furthermore
C(M ) =
Thus the cost of M is the total length of all the rectangles in ϑ(M ) and the expected score hM, Πi is the total area of all the rectangles in ϑ(M). It is intuitively clear that to maximize the total area for a given total length, one has to choose the highest rectangles.
This is precisely what Algorithm A does: the algorithm constructs the matrix M(Π, s) that corresponds to the set of s highest rectangles in B. Indeed, it is easy to see that the ratios πi,j∗ with which Algorithm A operates are precisely the heights of the rectangles.
The algorithm removes from B and puts in ϑ(M) the highest rectangle available at each iteration. It is now obvious that if the s highest rectangles in B have total length C, then no collection of rectangles of total length at most C can have a larger total area.
Chapter 4
Reduced-Complexity
Interpolation-Based Soft-Decision RS Decoders
The KV soft-decision decoding procedure results in very impressive error correcting performance. Nevertheless, the algorithm is still quite computationally complex and not straightforward to implement. This chapter introduces algorithmic techniques that re-duce the complexity of interpolation-based decoders to the point where efficient software or VLSI implementations are possible.
4.1 Modified Interpolation
The interpolation algorithm is the most time-consuming component of KV decoding and it is essential to reduce its complexity if KV decoding is to be used in real-time applications. From the discussion in section (2.4), if a multiplicity matrix has a maximum entry m, then the maximum interpolation cost would be the cost of hard-decision GS decoding with multiplicity m:
C = (n
2)m(m + 1)
. For the remainder of this discussion, we will assume the worst-case where the cost of interpolation is the maximum possible cost, C. The interpolation algorithm needs to store (dy+ 1) bivariate polynomials.(dy is the maximal y−degree) Since a homogeneous
linear system must have more unknowns than equations, the length (number of terms) of the polynomials must be at least C. The memory requirements of interpolation are
≈ (dy + 1)C field elements. Therefore the complexity of interpolation in terms of the number of Galois field operations is Nop,interp = O(dyC2).
Example 10 Consider a decoder for a (255,239) RS code with maximum multiplicity m = {1, 4, 16}. The interpolation cost, complexity and memory requirements are sum-marized in Table (4.1).
m C N
op,interpmemory
1 255 1 × 10
5512 bytes 4 2550 3 × 10
712 Kbytes 16 34680 2 × 10
10576 Kbytes
Table 4.1: The maximum cost, complexity (Nop,interp) and memory requirements for the interpolation algorithm applied to a RS(255,239) code with maximum multiplicity m. The data is from [5]
¿From Table(4.1) we see that the decoding complexity and memory requirements grow very quickly as the multiplicity increases. If the maximum multiplicity is fixed to deliver a desired error-rate, then to lower the cost and hence the complexity, the number of interpolation points (nonzero entries in the multiplicity matrix) that we apply the bivariate interpolation algorithm to must be reduced. We apply the trick of ”reencoding”
the received word to reduce the interpolation complexity.
4.1.1 Systematic Encoding
A systematic encoding is one where all the k input symbols to the encoder explicitly appear in the encoded codeword. If they appear in k consecutive positions then the encoding is called strictly systematic. Strictly systematic encoders, where the k message symbols appear as the last k symbols in a codeword, are easily implemented with a linear feedback shift register [6] and are commonly used.
Interpolation-based decoding algorithms rely on an evaluation map encoding, how-ever it is more efficient to implement an encoder as a linear feedback shift register. We would also like to apply the decoder to existing RS transmission systems that use a systematic encoder. Therefore we would like to use a systematic encoding in place of the evaluation map encoding.
We are also interested in generating systematic encodings where the information ap-pears in arbitrary positions in an encoded codeword. If these positions can change for ev-ery encoder use, then an efficient way of implementing this systematic encoder is with an erasures-only RS decoder [6]. Since RS codes are minimum-distance-separable (MDS), a codeword may be perfectly recovered from any k of its symbols. An erasures-only decoder is much simpler than an error-and-erasures decoder since the erasure locations are known a-priori. Therefore, the expensive iterative Berlekamp-Massey algorithm for solving the key equation and the Chien search root-finding can be skipped .
4.1.2 Re-encoding
The idea of re-encoding is to transform the interpolation problem into one that is easier to solve. The codeword c is transmitted through a noisy channel. The hard decision vector, r = (r0, r1, · · · , rn−1), which can be extracted from the reliability matrix Π, is r = c + e, where e is an error vector. The first step is to partition the received symbols in r into two sets, U (”unreliable”) and R (”reliable”). The set R consists of the k most reliable symbols, where the reliability information can be derived from the reliability matrix Π. The set of positions of the symbols in R(labeled from 1 to n corresponding to {α1, α2, · · · , αn}) is the set Rk. Now systematically encode the symbols in R so that they appear in the reencoded codeword, ψ,in the same positions that they appeared in r. As discussed in Section (4.1.1), this can be done efficiently for k arbitrary
positions with an erasures-only decoder. Taking the difference between r and ψ we get:
r0 = r − ψ (4.1)
= (c + e) − ψ (4.2)
= (c − ψ) + e (4.3)
which is a codeword (by the linearity of the code) that is corrupted by the same error pattern as r. However, r0 has a very interesting property; since the reencoding of r is systematic, k symbols of r0 are zero. These zero symbols correspond to k interpolation points with a zero y−component:
V = {(αi, 0)}, i ∈ Rk (4.4)
An interpolation polynomial for the k points in V is v(x)m where v(x) is found through a simple univariate interpolation:
v(x) = Y
i∈Rk
(x − αi) (4.5)
The advantage for high-rate codes is that we have found an interpolation polynomial for most of the points without having to use the expensive bivariate interpolation algorithm.
The calculation of v(x) requires a single polynomial to be updated k times instead of (dy + 1) polynomials being updated (k/2)(m2 + m) times. Now that we have v(x), the bivariate interpolation algorithm is run at decode time starting from the initial polynomial set:
G = {v(x)m, v(x)m−1y, ..., v(x)m−dyydy} (4.6) and run for at most
C0 = (n − k
2 )(m)(m + 1)
= (1 − k n)C
iterations, where C is the maximum cost of the bivariate interpolation without reencod-ing. The reduced cost, C0, gets smaller as the code rate k/n increases.
4.1.3 Reducing the Memory Requirements
The memory requirements for interpolation can be very large since the maximum length of the bivariate polynomials is at least C terms. The polynomials can be shortened by factoring out the polynomial v(x). It is shown in [7],[8] that if reencoding is used then the interpolation polynomial P (x, y) can be written as:
P (x, y) =
This is the most general way to decompose P (x, y) and it allows any k symbols to be chosen for R. However, it seems that the most logical choice for R is to choose the k symbols with the largest reliability (largest multiplicities) to achieve the maximum com-plexity reduction. To obtain the shortest possible polynomials, we make the assumption that R consists of k points that have the maximum possible multiplicity m = dy. Then Tj(x) = 1, j = 0, · · · , dy and Eq.(4.7) reduces to [10]:
which means that common factors of v(x) are being carried around needlessly, wasting memory. It would be nice to factor out the powers of v(x) and only have to calculate the wj(x) in real-time. The interpolation polynomial can be written as
P (x, y) =
The decoding algorithm takes the transformed word r0 as input and tries to estimate the transformed codeword c0 = c − ψ. Therefore, if the decoding is successful, a message
polynomial f0(x) corresponding to c0 will be a linear y−root of P (x, y), i.e.:
Define the reduced interpolation polynomial : P (x, ee y) = is a linear ey-root of the reduced interpolation polynomial eP (x, ey). A simplified interpo-lation can be carried out to find eP (x, ey) which is much shorter than P (x, y) since the degree k polynomial v(x) has been factored out in advance. To implement the simpli-fied interpolation, consider the original set of polynomials, G = {1, y, · · · , ydy}. After applying the reencoding technique, the starting polynomial set for decoding is:
G0 = {v(x)m, v(x)m−1y, · · · , v(x)m−dyydy} (4.17) weighted degree of the new variable ey is :
deg(1,k−1)(ey) = deg(1,k−1)(y) − deg(1,k−1)(v(x))
= (k − 1) − k
= −1.
The y-coordinates of the interpolation points need to be rescaled:
e
yi = yi0
v(xi) (4.19)
where the yi0 are the y-coordinates of points after the translation in the reencoding step. Starting from eG = {1, ey, · · · , eydy}, one applies the KV interpolation algorithm to the O(n − k) rescaled points where the min function is taken with respect to the (1,-1)-weighted degree of the polynomials in x and ey. A formal proof that simplified interpolation produces a correct result is given in [7] where the factorization step is slightly modified. This will be discussed in the following.
However, from (4.9), the simplified interpolation is not always realizable in all cases.
It must satisfy
Lemma 8 The maximum y-degree is equal to m.