GENERATION OF SPATIALLY-COUPLED QUASI-CYCLIC LDPC CODES

Abstract

The invention relates to an apparatus for providing at least one parity check matrix defining a spatially-coupled low density parity check, LDPC, code on the basis of a set of base matrix parameters defining a plurality of base matrices, each base matrix of the plurality of base matrices being associated with a protograph of a plurality of protographs, wherein the apparatus comprises: a processor configured to: generate on the basis of the plurality of protographs a set of candidate protographs by discarding protographs of the plurality of protographs; lift the protographs of the set of candidate protographs for generating a plurality of codes; and generate on the basis of a plurality of codes a set of candidate codes by discarding codes of the plurality of codes.

Description

TECHNICAL FIELD

The present invention relates to the field of channel coding. More specifically, the invention relates to devices and methods for generating a low density parity check (LDPC) code.

BACKGROUND

Error-correcting coding is an efficient method of approaching the capacity of a communication system. LDPC codes, which constitute one class of error correcting codes, have been introduced in 1962. Due to the limitation in computational effort in implementing the coder and decoder for such codes and the introduction of Reed-Solomon codes, LDPC codes have been ignored for almost 30 years. During that long period, the only notable work done on the subject was a generalization of LDPC codes and the introduction of a graphical representation of these codes, which is referred to as Tanner graph. Since 1993, with the introduction of turbo codes, researchers switched their focus to finding low complexity codes which can approach the Shannon channel capacity.

It is well known that the performance of randomly constructed irregular LDPC codes closely approach the Shannon limit for the additive white Gaussian noise (AWGN) channel as the code length becomes larger. Moreover, it has been shown that it is possible for irregular LDPC codes with a block length of 10⁷ to come very close (i.e. 0.0045 dB) to the Shannon capacity.

Although a randomly constructed LDPC code shows a good asymptotic performance, its randomness hinders the ease of analysis and implementation. In attempts towards an algebraic construction of LDPC codes, a quasi-cyclic (QC) LDPC code has been receiving increased attention, because it can be encoded in linear-time with shift registers and a small size of required memory.

With the increasing demand for applications requiring high data rates, many recent communication systems employ ultra-high throughput QC-LDPC codes to match the data-rate requirements, such as those posed by the next generation or 5G wireless communication systems.

Spatially-Coupled LDPC codes show excellent performance under moderate to high lengths and rates as well as simple structures, which reduce the complexity of analysis, design, and hardware implementation for rate and length adapted codes. These properties of SC-LDPC codes offer attractive possibilities for future coding standards.

US 2015/0155884 A1 discloses an example of designing a base matrix of a SC-LDPC code using an algebraic approach. More specifically, US 2015/0155884 A1 discloses an algebraic approach for generating a SC-LDPC code on the basis of a multiplicative group using the approach disclosed in R. M. Tanner, D. Sridhara, A. Sridharan, T. E. Fuja and D. J. Costello, “LDPC block and convolutional codes based on circulant matrices,” in IEEE Transactions on Information Theory, vol. 50, no. 12, pp. 2966-2984, December 2004.

U.S. Pat. No. 8,103,931 B2 discloses a method comprising graph lifting of a base matrix using a hill-climbing technique.

In light of the above, there is a need for improved devices and methods for generating LDPC codes.

SUMMARY

It is an object of the invention to provide devices and methods for generating LDPC codes.

The foregoing and other objects are achieved by the subject matter of the independent claims. Further implementation forms are apparent from the dependent claims, the description and the figures.

According to a first aspect the embodiments of the invention relates to an apparatus for providing at least one parity check matrix defining a spatially-coupled low density parity check, LDPC, code on the basis of a set of base matrix parameters defining a plurality of base matrices, each base matrix of the plurality of base matrices being associated with a protograph of a plurality of protographs, wherein the set of base matrix parameters defines the size WxC, a circulant size N, a maximal column weight M and a set of allowed column weights of the plurality of base matrices, wherein the apparatus comprises: a processor configured to: generate on the basis of the plurality of protographs a set of candidate protographs by discarding protographs of the plurality of protographs; lift the protographs of the set of candidate protographs for generating a plurality of codes; and generate on the basis of a plurality of codes a set of candidate codes by discarding codes of the plurality of codes, wherein the processor is configured to lift the protographs of the set of candidate protographs on the basis of a simulated annealing technique.

In a first possible implementation form of the apparatus according to the first aspect as such, the processor is configured to discard those protographs of the plurality of protographs that are associated with a LDPC code having a minimum Hamming distance that is larger than a minimum Hamming distance threshold value.

In a second possible implementation form of the apparatus according to the first implementation form of the first aspect, the processor is configured to estimate the minimum hamming distance of a LDPC code C on the basis of the upper bound defined by the following equation:

$d_{\min }\left(C\left(H\right)\right)\le \underset{\underset{S=C+1}{S^{\subseteq \subseteq }\left[W\right]}}{{\min }^{+}}\sum _{i\in S}\mathrm{perm}\left(A_{S\backslash i}\right)$

wherein[W] denotes the set of numbers from [0 . . . W−1],the operator min⁺( . . . ) defines the minimal positive value of its argument, andthe permanent operator perm( . . . ) is defined by the following equation:

$\mathrm{perm}\left(B\right)=\sum _{\sigma }\prod _{j\in \left[m\right]}b_{j,\sigma \left(j\right)}$

whereinB is a m×m matrix having elements b_j,σ(f) andσ takes all m! possible permutations of the set [m].

In a third possible implementation form of the apparatus according to the first or second implementation form of the first aspect, the minimum Hamming distance threshold value is (C+1)!.

In a fourth possible implementation form of the apparatus according to the first aspect as such or any one of the first to third implementation form thereof, the processor is further configured to discard protographs of the plurality of protographs on the basis of the balanced girth of the parity check matrix H associated with each protograph.

In a fifth possible implementation form of the apparatus according to the fourth implementation form of the first aspect, the processor is configured to discard those protographs from the plurality of protographs that are associated with a parity check matrix H having a balanced girth which is larger than a balanced girth threshold value.

In a sixth possible implementation form of the apparatus according to the first aspect as such or any one of the first to fifth implementation form thereof, the processor is further configured to lift a protograph of the plurality of protographs having at least one parallel edge to a protograph having no parallel edges.

In a seventh possible implementation form of the apparatus according to the first aspect as such or any one of the first to sixth implementation form thereof, the processor is further configured to discard those protographs of the plurality of protographs that are associated with an extrinsic message degree (EMD) that is smaller than an EMD threshold value.

According to a second aspect the embodiments of the invention relates to a corresponding method for providing at least one parity check matrix defining a spatially-coupled low density parity check, LDPC, code on the basis of a set of base matrix parameters defining a plurality of base matrices, each base matrix of the plurality of base matrices being associated with a protograph of a plurality of protographs, wherein the set of base matrix parameters defines the size W×C, a circulant size N, a maximal column weight M and a set of allowed column weights of the plurality of base matrices, wherein the method comprises the steps of: generating on the basis of the plurality of protographs a set of candidate protographs by discarding protographs of the plurality of protographs; lifting the protographs of the set of candidate protographs for generating a plurality of codes; and generating on the basis of a plurality of codes a set of candidate codes by discarding codes of the plurality of codes, wherein the step of lifting the protographs of the set of candidate protographs is based on a simulated annealing technique.

The method according to the second aspect of the embodiments of the invention can be performed by the apparatus according to the first aspect of the embodiments of the invention. Further features of the method according to the second aspect of the embodiments of the invention result directly from the functionality of the apparatus according to the first aspect of the embodiments of the invention and its different implementation forms.

According to a third aspect the embodiments of the invention relates to a computer program comprising program code for performing the method according to the second aspect of the embodiments of the invention when executed on a computer.

The embodiments of the invention can be implemented in hardware and/or software.

BRIEF DESCRIPTION OF DRAWINGS

Further embodiments of the invention will be described with respect to the following figures, wherein:

FIG. 1 shows a schematic diagram illustrating an apparatus for generating a LDPC code according to an embodiment;

FIG. 2 shows a schematic diagram illustrating an exemplary block of circulants shifted by two different values;

FIG. 3 shows a schematic diagram illustrating an exemplary spatially coupled parity-check matrix represented by blocks of circulants;

FIG. 4 shows a schematic diagram of exemplary blocks of circulant permutation matrices and spatially coupled blocks of circulant permutation matrices;

FIG. 5 shows a schematic diagram of an exemplary protograph having a trapping set;

FIG. 6a shows a schematic diagram illustrating a protograph selection or optimization stage of the code generation according to an embodiment;

FIG. 6b shows a schematic diagram illustrating a protograph lifting optimization stage of the code generation according to an embodiment;

FIG. 7 shows a schematic diagram illustrating two exemplary protographs with two cycles having the same ACE value and different EMD values;

FIG. 8a shows a schematic diagram illustrating an exemplary cycle in a protograph having a left edge intersecting shifted zone;

FIG. 8b shows a schematic diagram illustrating an exemplary cycle in a protograph having no closed cycle in the spatially coupled graph;

FIG. 9 shows a schematic diagram illustrating an exemplary 4VN subgraph of a protograph;

FIG. 10a shows a diagram illustrating the performance of codes provided by embodiments of the invention in comparison with conventional codes;

FIG. 10b shows a diagram illustrating the performance of codes provided by embodiments of the invention in comparison with conventional codes;

FIG. 11a shows a diagram illustrating the performance of codes provided by embodiments of the invention in comparison with conventional codes; and

FIG. 11b shows a diagram illustrating the performance of codes provided by embodiments of the invention in comparison with conventional codes.

In the various figures, identical reference signs will be used for identical or at least functionally equivalent features.

DESCRIPTION OF EMBODIMENTS

In the following description, reference is made to the accompanying drawings, which form part of the disclosure, and in which are shown, by way of illustration, specific aspects in which the present invention may be placed. It is understood that other aspects may be utilized and structural or logical changes may be made without departing from the scope of the present invention. The following detailed description, therefore, is not to be taken in a limiting sense, as the scope of the present invention is defined be the appended claims.

For instance, it is understood that a disclosure in connection with a described method may also hold true for a corresponding device or system configured to perform the method and vice versa. For example, if a specific method step is described, a corresponding device may include a unit to perform the described method step, even if such unit is not explicitly described or illustrated in the figures. Further, it is understood that the features of the various exemplary aspects described herein may be combined with each other, unless specifically noted otherwise.

FIG. 1 shows a schematic diagram illustrating an apparatus 100 for providing a parity check matrix defining a spatially-coupled low density parity check, LDPC, code on the basis of a base matrix defining a quasi-cyclic LDPC code. The apparatus 100 comprises a processor 101 configured to: generate on the basis of a plurality of protographs associated with the base matrix a set of candidate protographs by discarding protographs of the plurality of protographs; lift the protographs of the set of candidate protographs for generating a plurality of codes; and generate on the basis of a plurality of codes a set of candidate codes by discarding codes of the plurality of codes.

The processor 101 is configured to lift the protographs of the set of candidate protographs on the basis of a simulated annealing technique, as will be described in more detail further below.

Before describing some further details of the apparatus 100 shown in FIG. 1 and different embodiments thereof, the following “background material” is provided for a better understanding of different embodiments of the apparatus 100.

A (W, C, N, L) tail-bitten spatially-coupled QC-LDPC code C(H) of length W multiple L multiple N (i.e. if the circulant size is N×N with W circulants coupled L times) can be defined by a parity-check base matrix H in the following way:

$\begin{array}{cc}H=\left[\begin{array}{cccc}{A}_{0,0}& A_{1,0}& \dots & A_{\mathrm{WL}-1,0}\\ A_{0,1}& A_{1,1}& & A_{\mathrm{WL}-1,1}\\ ⋮& ⋮& \ddots & ⋮\\ A_{0,\mathrm{CL}-1}& A_{1,\mathrm{CL}-1}& \dots & A_{\mathrm{WL}-1,\mathrm{CL}-1}\end{array}\right]& \left(1\right)\end{array}$

• • wherein 0≤i≤CL−1, 1≤j≤WL−1 and a circulant permutation matrix (CPM) A_i,j represents either the N×N zero matrix Z or the N×N circulant permutation matrix I(p_i,j) obtained by cyclically right-shifting the N×N identity matrix I(0) by p_i,j positions. Denote by CPM-column the i-th column of A_0,i, A_1,i, . . . , A_CL-1,i. In a similar way define CPM-row.

For a specific tail-bitten spatially-coupled QC-LDPC code the corresponding CPM-shifts matrix can be defined as the matrix of circulant shifts that defines the QC-LDPC code, i.e.:

$\begin{array}{cc}B=\left[\begin{array}{cccc}{b}_{0,0}& b_{1,0}& \dots & b_{W-1,0}\\ b_{0,1}& b_{1,1}& & b_{W-1,1}\\ ⋮& ⋮& \ddots & ⋮\\ b_{0,C-1}& b_{1,C-1}& \dots & b_{W-1,C-1}\end{array}\right]& \left(2\right)\end{array}$

The corresponding shifts can be represented as a vector D of shifts:

$\begin{array}{cc}D=\left[\begin{array}{c}{d}_0\\ d_1\\ ⋮\\ d_{C-1}\end{array}\right]& \left(3\right)\end{array}$

• • with the conditions d₀=0, d_i<d_j iff i<j,∀i d_i<W. If

$\frac{W}{C}$

is an integer, the vector D can be defined as

$d_i=\frac{\mathrm{iW}}{C}.$ For 0≤i≤CL−1,0≤j≤WL−1, if

i′ mod WL≤i<(i′+W)mod WL

then A_i,j=I(b_{i mod W,j mod C}) else A_i,j=Z.

The above definitions are further illustrated by FIGS. 2 to 4. FIG. 2 shows a schematic diagram illustrating an exemplary block of circulants shifted by two different values. FIG. 3 shows a schematic diagram illustrating a spatial coupled parity-check matrix represented by blocks of circulants. FIG. 4 shows a schematic diagram of a blocks of circulant permutation matrices and spatially coupled blocks of circulant permutation matrices.

There is a more general case of parity check matrices, where one circulant permutation matrix can have more than one diagonal.

A weight matrix (or protograph) wt(H) of a matrix H is a matrix of number of diagonals for each circulant of H.

A type M of the matrix H is a maximal value of the matrix wt(H).

Given a protograph matrix H of type M>1, a matrix with circulant size equal to M can be generated. Choosing in each circulant the number of diagonals equal to corresponding weight, the result can be considered as a new protograph matrix H′. The type of the new protograph matrix H′ is 1, and most properties of H′ will remain the same as for H. Thus, without loss of generality only protograph matrices of type 1 can be considered, when it is necessary.

There is isomorphism between the ring of circulant permutation matrices over some field F and the ring F-polynomials modulo x^N−1, where N is the size of the circulant. For example I(0) can be represented as x⁰, I(5) as x⁵, and I(0)+I(1)+I(4) as x⁰+x¹+x⁴.

A very important characteristic of a parity check matrix is the girth of its Tanner graph, which is defined as the minimal length of a cycle of the Tanner graph of a parity check matrix. A cycle in a Tanner graph can be defined in the following way: . . . .

Cycle of even length 2K in H defined by 2K positions of ones such that:

• • 1) Two consecutive positions are obtained by changing alternatively column of row only;
  • 2) All positions are distinct except first and last one;

Two consecutive elements of the path belong to different circulant permutation matrices. Thus, a chain of circulant permutation matrices can be defined as follows:

A _{i 0 ,j 0} ,A _{i 0 ,j 1} ,A _{i 1 ,j 1} ,A _{i 1 ,j 2} , . . . A _{i K−1 ,j K−1} ,A _{i K−1 ,j 0} ,A _{i 0 ,j 0} ,

where i_a≠i_a+1,j_a≠j_a+1, for all 0≤a≤K−1.

As each part of a cycle is one, a circulant permutation matrix A_i,j participating in the cycle cannot be empty. In other words, A_i,j=I(p_i,j).

Using these shifts of the identity matrix the necessary and sufficient conditions for the existence of the cycle can be expressed as follows:

$\begin{array}{cc}\sum _{a=0}^{K-1}p_{i_a,j_a}-p_{i_a,j_{a+1}}\equiv 0\left(\mathrm{mod}N\right)& \left(4\right)\end{array}$

The Tanner graph T(H) of a parity check matrix H is a bipartite graph with two set of vertices, referred to as variable nodes V={ν₀, ν₁, . . . , ν_n−1} and check nodes C={c₀, c₁, . . . , c_n−1}. The columns of the matrix H correspond to the variable nodes, and the rows thereof to the check nodes. There is an edge between a variable node ν_i and a check node c_j, if any only if the cell of H at the i-th column and the j-th row is nonzero.

A trapping set T of type (T₁, T₂) is a connected subgraph of a Tanner graph, including T₁ variable nodes, where T₂ check nodes are connected with the trapping set T by an odd number of edges.

Simultaneously altering values of T₁ variable nodes and T₂ check nodes gives correct result. It means that wrong bit in T₂ check nodes gives wrong decoding of T₁ variable nodes. A small value of T₂ gives bad trapping sets, as it more easy to make mistakes in a small number of nodes. Trapping sets with bigger value of T₂ are worse as more informational bits are wrong. Differently put, if wrong bit place to variable nodes incident to odd degree check node, then Belief Propagation decoder most commonly fails due to this error (even if the code distance is greater than this number error). The graph properties are the reason for this error.

FIG. 5 shows a schematic diagram of an exemplary protograph having a trapping set.

FIG. 6a shows a schematic diagram illustrating a protograph selection or optimization stage of the code generation provided by the apparatus 100 according to an embodiment. FIG. 6b shows a schematic diagram illustrating a protograph lifting stage and subsequent code selection stage of the code generation provided by the apparatus 100 according to an embodiment.

In an embodiment, the input of the code generation stages shown in FIGS. 6a and 6b are the parameters of a base matrix, namely its size W×C (e.g. 32×16), a circulant size N, a maximal column weight M and a set of allowed column weights. As will be explained in more detail below, the final output of the code generation stages shown in FIGS. 6a and 6b is a set of selected parity check matrices providing good LDPC codes.

The code generation stages shown in FIGS. 6a and 6b comprises generator blocks (indicated as three-dimensional processing blocks in FIGS. 6a and 6b) and filter or selection blocks (indicated as two-dimensional processing blocks in FIGS. 6a and 6b). Each generator block is configured to generate either a protograph or a parity check matrix (based on the given protograph). Each filter or selection block filters its input in some way and, thereby, performs a selection operation on the basis of its input.

The first stage shown in FIG. 6a illustrates two branches, namely a first branch which generates protographs in processing block 603, when the input base matrix is smaller than a predefined threshold (i.e. when the search is not too complex) and a second branch which comprises processing blocks 602, 604 and 606, when the base matrix is larger than a predefined threshold (for example, for estimating an upper bound on the code distance it is may necessary to enumerate 1.1826e+17 permanents for a base matrix 30×60 and permanents of size 30×30).

In the following several of the processing blocks shown in FIGS. 6a and 6b and implemented in an embodiment of the apparatus 100 will be described in more detail.

In the processing step 603, the processor 101 of the apparatus 100 is configured to consider possible protograph matrices for a given length N and rate K/N. If K and N are not too large enough, the processor 101 can enumerate all protographs.

In an embodiment, the processor 101 is configured to estimate in the next processing step 605 the quality of a QC-LDPC code based on a protograph A by estimating the minimum Hamming distance of the code.

The permanent of the m×m base matrix B is

$\mathrm{perm}\left(B\right)=\sum _{\sigma }\prod _{j\in \left[m\right]}b_{j,\sigma \left(j\right)}$

• • where σ takes all m! possible permutations of the set [m]. The function min⁺( ) denotes minimal positive value and [W] denotes the set of numbers from [0 . . . W−1]. Then, the upper bound d_min for QC code C(H) with polynomial parity-check matrix can be expressed in the following way:

$\begin{array}{cc}{d}_{\min }\left(C\left(H\right)\right)\le \underset{\underset{S=C+1}{s^{\subseteq \subseteq }\left[w\right]}}{{\min }^{+}}\sum _{i\in S}\mathrm{perm}\left(A_{S\backslash i}\right)& \left(5\right)\end{array}$

According to an embodiment, the processor 101 is configured to further process a code if the upper bound d_min is not less than (C+1)! in the processing block 605. In other words, in the processing block 605 the processor 101 is configured to discard protographs or corresponding codes with an upper bound d_min being smaller than (C+1)!.

The following example illustrates the use of equation (5), as applied by the processor 101 in embodiments of the invention. Consider two (2,4) regular length-4r QC codes, namely a first code C(H₁) with parity check matrix

$H_1\left(x\right)=\left(\begin{array}{cccc}x& x^2& x^4& x^8\\ x^5& x^6& x^3& x^7\end{array}\right),$

and a second code C(H₂) with parity check matrix

$H_2\left(x\right)=\left(\begin{array}{cccc}x& x^2& x^4& x^8\\ x^6& x^5& x^3& x^9\end{array}\right).$

For both codes equation (5) provides:

d _min≤min⁺{(1+1)+(1+1)+(1+1)}=6

Σ_a=0^K−1p_ia,ja−p_ia,ja+1≡0(mod N)  (4)

In above equation (4) each coefficient p_i,j for the CPM A_i,j adds with plus for each even step and with minus for each odd steps. If the number of even steps for the CPM A_i,j equals the number of odd steps, then p_i,j can be eliminated from above equation (4).

A balanced cycle on the parity check matrix H is the cycle where each cell participates the same number of times in even steps and in odd steps. For a balanced cycle above equation (4) reduces to the trivial equality 0≡0, which holds for any values of coefficients p_i,j.

In the processing block 607 the processor 101 is configured to estimate the minimal length of the balanced cycle for each protograph candidate.

The balanced girth is defined as the minimal length of the balanced cycle. The actual girth cannot be larger than the balanced girth of a parity check matrix H for any shifts of circulant permutation matrices. For this reason, the balanced girth is an important upper bound for the girth of a protograph, as implemented in embodiments of the invention.

In the following, a pseudo code for estimating the balanced girth of the parity check matrix H will be described, as implemented in embodiments of the invention. Here, K denotes a pre-defined constant. This pre-defined constant can be selected as a trade-off. After a certain value of balance cycle, the code distance can become too bad. Thus, the pre-defined constant can be selected as the point, where the cycle is enough to prevent performance degradation by TS and code distance.

Enumerate all closed cycles with length shorter than given K, going through non-empty protograph cells, with vertical lines on even steps, and horizontal lines on odd steps.

• • 1. For each cycle from enumeration calculate whether this cycle is balanced or not.
  • a. For each cell of the cycle calculate difference between the appearance after even and after odd steps.
  • b. The cycle is balanced, if and only if all differences are zero.
  • 2. Return minimal length of the balanced cycle.

In processing block 609, the processor 101 is configured to determine for each candidate protograph, whether the protograph has parallel edges. If this is the case, the processor 101 is configured to lift in processing block 610 a corresponding candidate protograph A having some parallel edges to a bigger protograph without parallel edges using a quasi-cyclic technique. For a protograph of type K, the minimal possible value of the circulant size K is chosen and changed for each.

In processing block 611, the processor 101 is configured to discard protographs having a small Extrinsic Message Degree (EMD), i.e. an EMD smaller than a predefined threshold. The EMD of a cycle in the Tanner graph is defined as the number of check nodes singly connected to the variable nodes involved in the cycle. The EMD value of a code is an important characteristic, because each cycle C_2n of length 2n is a trapping set (n, EMD(C_2n)).

The Approximate Cycle EMD (ACE) is defined as the number of incident edges not included in the cycle. For a cycle C_2n of length 2n the following relation holds

Σ_k=1²ⁿACE(c_2n)=(d_νk−2),

where d_νk denotes the degree of k-th variable node.

FIG. 7 shows a schematic diagram illustrating two protographs with two cycles having the same ACE value, namely ACE=5, and different EMD values, namely EMD=5 for the protograph on the left and EMD=3 for the protograph on the right.

The ACE spectrum μ_ACE=(μ₂, μ₄, . . . , μ_dACE) of a Tanner graph is defined as the set of minimum ACE values of a given length range from 2 up to d_ACE of the graph. If there are no cycles of length k, then μ_k=∞.

It has been shown that the ACE and the EMD value(s) can be related in the following ways.

First, for a code with a girth g the following relation holds for a cycle C_k having a length k<2 g−4: ACE (C_k)=EMD(C_k).

Second, for a code with the girth g and the ACE spectrum μ_ACE=(μ₂, μ₄, . . . , μd_ACE), ACE(C_k) of the cycle C_k of length k, k≥2 g−4 is equal to EMD(C_k) if

$ACE\left(C_k\right)<\underset{j\in \left\{g,g+2,\dots ,k+4-g\right\}}{\min }\frac{{\mu }_j+{\mu }_{k-j+4}}{2}$

These relations between the ACE and the EMD are illustrated by the following examples.

For a LDPC code of girth 12, all the cycles of length 12, 14, 16 and 18 have equal ACE and EMD.

For a LDPC code with ACE spectrum (∞, ∞, 15, 11, 16) all the cycles of length 8 with the ACE value less than 13 will have equal ACE and EMD.

For all cycles of length 10 and ACE value less than

$13=\frac{15+11}{2}.$

In an embodiment, the processor 101 is configured to make use of one or more of the above relations between the ACE and the EMD in the processing block 611 for a fast evaluation of the EMD for cycles in protographs. This, in turn, allows the processor 101 to estimate the number of trapping sets and, thus, the quality of a protograph in the processing block 611.

In an embodiment, for a given protograph the following assumptions are made: non-existence of cycles and hence a Gaussian distribution for LLR on the belief propagation algorithm. On the basis of these assumptions the decoding threshold of an ensemble of protographs characterized by a given distribution of variable nodes and check nodes can be calculated, as implemented in embodiments of the present invention.

We plot chart of two EXIT functions I_E,V and I_E,C.

The step function shows the growth of the information obtained by the belief propagation algorithm. If the EXIT functions are not intersecting, the belief propagation algorithm can be terminated. The decoding threshold can be defined as the value of the noise, when the two EXIT functions touch each other. The two EXIT functions I_E,V and I_E,C can be expressed in the following way:

$I_{E,V}=J\left(\sigma \right)=J\left(\sqrt{\left(d_v-1\right){\sigma }_A^2+{\sigma }_{\mathrm{ch}}^2}\right)$ $J\left(\sigma \right)=1-{\int }_{-\infty }^{\infty }\frac{1}{\sqrt{2\pi }\sigma }e^{-{\left(l-\frac{{\sigma }^2}{2}\right)}^2/2{\sigma }^2}\log \left(1+e^{-l}\right)\mathrm{dl}$ $I_{A,V}=J\left({\sigma }_A\right)$ $I_{E,V}=J\left(\sigma \right)=J\left(\sqrt{{\left(d_v-1\right)\left[J^{-1}\left(I_{A,V}\right)\right]}^2+{\sigma }_{\mathrm{ch}}^2}\right).$

In an embodiment, the following approximation can be used for I_E,C:

I _E,C=1−J(√{square root over ((d_c−1)[J⁻¹(1−I_A,C)]²)}).

For irregular LDPC codes I_E,V and I_E,C can be calculated as weighted averages, as implemented in an embodiment of the invention.

In an embodiment, the weighting is given by the coefficients of the edge degree distribution polynomials λ(z)=Σd_d=1^dνλ_dz^d−1 and ρ(z)=Σ_d=1^dcρ_dz^d−1, where λ_d is the fraction of ones in the columns in the protograph with d ones in the column, and ρ_d is the fraction of ones in the rows in the protograph with d ones in the row. For irregular LDPC codes this results in:

I _E,V=Σ_d=1^dνλ_dI_E,V(d,I_A,V)

I _E,C=Σ_d=1^dνρ_dI_E,C(d,I_A,C)

In an embodiment, a pre-calculated approximation function J(⋅) can be used having an accuracy of, for instance, better than 10⁻⁵.

On the basis of the weighted functions I_E,V(d,I_A,V) and I_E,C(d,I_A,C) the processor 101 can be configured to calculate the following iterations:

I _A,V ⁽⁰⁾=0

I _A,V ⁽ⁿ⁺¹⁾ =I _E,C(d,I_E,V(d,I_A,V⁽ⁿ⁾))

In an embodiment, the processor 101 is configured to stop the iteration, when I_A,V⁽ⁿ⁾ is close to 1.

For each distribution of weights λ_d,ρ_d the minimal

$\frac{E_b}{N_0}$

(based on σ_A²) is calculated, when the iteration converges to 1 for a fixed number of steps.

Using EXIT charts, i.e. graphical representations of the exit functions, good distributions λ_d,ρ_d can be generated and thereafter protographs with given distributions of ones in rows and columns can be created, as implemented in embodiments of the invention and as will be described in more detail in the following.

For each value of λ_d the processor 101 is configured to generate a set of all possible columns, which provides this value λ_d. In an embodiment, parallel edges in the protograph are allowed, i.e. a cell can not only have the values 0 and 1, but larger values as well.

In an embodiment, the processor 101 is configured to generate protographs with given weights of rows using a backtracking algorithm. In this way, the processor 101 generates a set of protographs A possibly having a w eight larger than 1. On the basis of this set of protographs A the processor 101 is configured to construct parity check matrices H(x) with wt(H(x))=A (processing block 604 of FIG. 6a).

In an embodiment, a frame error rate (FER) threshold can be selected and the processor 101 is configured to perform the iterations of the belief propagation algorithm, until the smallest possible

$\frac{E_b}{N_0}$

satisfying the FER threshold has been determined. From different codes we choose that one which provides a lower

$\frac{E_b}{N_0}.$

In processing block 615, the processor 101 is configured to perform a base matrix lifting based on simulated annealing. To this end, a parameter K can be selected as the desired girth. In a first stage, a random initial parity check matrix can be generated by taking random values of shifts for non-empty circulant permutation matrices. This matrix usually has very low girth. Also a special parameter temperature is chosen associated with the simulated annealing approach with relatively high value.

In a second stage, the processor 101 is configured to iteratively improve the initial parity check matrix by repeating the procedure defined by the following pseudo code.

• • 1. Nstep=0
  • 2. Choose one random non-empty cell of the protograph.
  • 3. Enumerate all possible cycles through this cell of length shorter than K.
  • 4. Calculate number of existing cycles “ShiftCycles” for all possible shift values of this cell (using the techniques described above).
  • 5. Take randomly one of these values with probability depending on the value of cycles and the temperature parameter of the annealing method. The probability weight function should be greater for smaller values of ShiftCycles(m), and the difference increases with a reduction of the temperature. One example of such probability weight function is

$w\left(m\right)=e^{\frac{-\mathrm{ShiftCycles}\left(m\right)}{\mathrm{Temperature}}}$

• • 6. Exact probability of choice m is p(m)=w(m)/Σ_i=0^N−1w(i).
  • 7. Decrease value of temperature. In each step, the temperature should monotonically decrease. One example of a formula for decreasing the temperature is

$\mathrm{Temperature}=\mathrm{Const}\frac{\mathrm{Total}\mathrm{number}\mathrm{of}\mathrm{cycles}\mathrm{in}\mathrm{protograph}}{{\mathrm{Nstep}}^2}$

• • 8. Increment Nstep and go to step 2.
  • 9. Then if the result is stable for many iterations, finish the procedure.

A main feature of embodiments of the invention is the enumeration of the paths going through a given cell and for each cycle the number of cycles for each value of the shift of CPM for the given cell is determined. In an embodiment, this is done on the basis of a modified backtracking algorithm, as defined by the following pseudo code:

• • 1. Define zero vector ShiftCycles of length N.
  • 2. Enumerate all closed cycles with length shorter than given K, starting and ending in the given cell going through non-empty protograph cells, with vertical lines on even steps, and horizontal lines on odd steps.
  • 3. Repeat the following procedure for each cycle:
  • 4. Consider all horizontal edges (for every 1≤a<K=j_a−1=j_a). Calculate the number of edges of the cycle which intersect the shifted zone of the protograph, and proceed to the left (i_a≤D(j_a), i_a−1>D(j_a−1) and to the right (i_a>D(j_a), i_a−1≤D(j_a−1). If the number of left intersections is not equal to the number of right intersections, it means that cycle is actually not-closed in the spatially-coupled matrix, and this cycle is discarded.
  • 5. Calculate signed sum R of appearing shift p_i0,j0 of initial cell in equation (4)
  • 6. Consider the starting cell to be a CPM with a shift p_i0,j0=0 I(0) (i.e. the circulant matrix with zero shift is the identity matrix) and calculate the total shift S=Σ_a=0^K−1p_ia,ja−p_ia,ja+1 mod N through this cycle.
  • 7. The shift of the starting cell p_i0,j0 in S always goes with sign +, so for an arbitrary shift the equation can be written as: R p_i0,j0+S=mod N, and the forbidden values for p_i0,j0 can be found. For each solution p_i0,j0 increment the value of ShiftCycles(p_i0,j0) (as described further above).

In an embodiment, the processor 101 is configured to solve the equation a x=b mod c occurring in step 7 of the above pseudo code in the following way:

• • 1. Take d=GCD (a, c)
  • 2. If b mod d≠0, there is no solution for x.
  • 3. If b mod d=0, take

$a^{\prime }=\frac{a}{d},b^{\prime }=\frac{b}{d},c^{\prime }=\frac{c}{d}$

and solve a′x=b′(mod c′).

• • 4. If a′=0 and b=0, every x is a solution
  • 5. If a′=0 and b≠0, there is no solution.
  • 6. If a′ ≠0 there is e=a′⁻¹ mod c′, i.e. a′e=1 mod c′, then x=b′e mod c′
  • 7. All solutions of the initial equation are x_k=b′e mod c′+k c′, for 0≤k<d.

FIG. 8a shows a schematic diagram illustrating a cycle in a protograph having a left edge intersecting shifted zone. FIG. 8b shows a schematic diagram illustrating a cycle in a protograph having no closed cycle in the spatially coupled graph.

The following examples illustrate the performance of the base matrix lifting based on the simulated annealing (SA) algorithm described above in comparison to a conventional base matrix lifting based on a hill-climbing (HC) algorithm.

In a first example, the value of the circulant for a regular protograph with row number 3 and column number L with girth 8 (less value better) can be taken from the following table for the two different algorithms mentioned above.

	L = 4	L = 5	L = 6	L = 7	L = 8	L = 9	L = 10	L = 11	L = 12
SA	9	13	18	21	25	30	35	40	45
HC	9	13	18	21	25	30	35	41	47

In a second example, the value of the circulant for a regular protograph with row number 3 and column number L with girth 10 (less value better) can be taken from the following table for the two different algorithms mentioned above.

	L = 4	L = 5	L = 6	L = 7	L = 8	L = 9	L = 10	L = 11	L = 12
SA	39	63	97	144	215	297	409	542	698
HC	39	63	103	160	233	329	439	577	758

As can be taken from these tables, in both examples the SA algorithm outperforms the HC algorithm, i.e. provides smaller circulant values, for different numbers of columns.

The processing block 617 shown in FIG. 6b is based on the following considerations.

Let H be a parity check matrix based on a regular (j,k)-code C(H) with length n (with n=WN) and let the corresponding Tanner graph have one component. Let ≙ H^T H and let μ₁,μ₂ be the largest and the second-largest eigenvalue, respectively, of L. It has been shown that in this case the minimum Hamming weight and the minimum AWGNC pseudo-weight have the following lower bounds:

$w_H^{\min }\left(C\left(H\right)\right)\ge w_p^{\min }\ge n·\frac{2j-{\mu }_2}{{\mu }_1-{\mu }_2}.$

This result can be applied not only to regular codes, but to non-regular codes as well in the following way:

$w_H^{\min }\left(C\left(H\right)\right)\ge w_p^{\min }\ge n·\frac{2j_{\mathrm{avg}}-{\mu }_2}{{\mu }_1-{\mu }_2},$

where j_avg is the average weight of the code C(H).

On the basis of the above relations the processor 101 is configured to discard codes having a small lower bound for the pseudo code weights.

In a block 619 of FIG. 6b the processor 101 is configured to perform the same selection as described in the context of block 611 of FIG. 6a.

In a processing block 621 of FIG. 6b the processor 101 is configured to perform a further selection step on the basis of a tighter upper bound for the minimum Hamming distance of the respective candidate parity check matrices on the basis of information about the CPM shifts.

Generally, the minimum Hamming distance is an important characteristic of a given parity check matrix. It provides an estimate for the level of undetectable errors as well as an upper bound on the minimum pseudo-weight of a Tanner graph representing a code.

If the size of the circulant of a spatially coupled code approaches infinity, the spatially coupled code becomes a convolution code. Consequently, a convolution code provides a good approximation for a spatially coupled code. As already mentioned above, [W] denotes the set of numbers from [0 . . . W−1]. It has been shown that for a QC code C(H) with a circulant parity check matrix H an upper bound for the minimum Hamming distance of the code is the following:

$\begin{array}{cc}{d}_{\min }\left(C\left(H\right)\right)\le \underset{\underset{S=C+1}{s^{\subseteq \subseteq }\left[w\right]}}{{\min }^{+}}\sum _{i\in S}\mathrm{wt}\left(\mathrm{perm}\left(H_{S\backslash i}\left(x\right)\right)\right)& \left(6\right)\end{array}$

In an embodiment, the processor 101 is configured to estimate a tighter upper bound for the minimum Hamming distance on the basis of equation (6). In an embodiment, the processor 101 is configured to keep a code, if the tighter upper bound of the Hamming distance provided by equation (6) is substantially equal to the upper bound provided by equation (5) (which, in turn, implies that the upper bounds are substantially equal to (C+1)!).

The use of equation (6), as implemented in embodiments of the invention, will be illustrated in the following on the basis of the two examples already mentioned above, i.e. for a first code C(H₁) with parity check matrix

$H_1\left(x\right)=\left(\begin{array}{cccc}x& x^2& x^4& x^8\\ x^5& x^6& x^3& x^7\end{array}\right),$

and a second code C(H₂) with parity check matrix

$H_2\left(x\right)=\left(\begin{array}{cccc}x& x^2& x^4& x^8\\ x^6& x^5& x^3& x^9\end{array}\right).$

As described above, equation (5) provides for both of these codes the same upper bound having the value 6.

Using equation (6) one obtains for the first code:

$d_{\min }\left(C\left(H_1\right)\right)\le {\min }^{+}\left\{\begin{array}{c}\mathrm{wt}\left(x^4+x^9\right)+\mathrm{wt}\left(x^5+x^{10}\right)+\mathrm{wt}\left(x^7+x^7\right)\\ \mathrm{wt}\left(x^9+x^{14}\right)+\mathrm{wt}\left(x^8+x^{13}\right)+\mathrm{wt}\left(x^7+x^7\right)\\ \mathrm{wt}\left(x^{11}+x^{11}\right)+\mathrm{wt}\left(x^8+x^{13}\right)+\mathrm{wt}\left(x^4+x^9\right)\\ \mathrm{wt}\left(x^{11}+x^{11}\right)+\mathrm{wt}\left(x^9+x^{14}\right)+\mathrm{wt}\left(x^5+x^{10}\right)\end{array}\right\}={\min }^{+}\left\{4,4,4,4\right\}=4$

Using equation (6) one obtains for the second code:

$d_{\min }\left(C\left(H_2\right)\right)\le {\min }^{+}\left\{\begin{array}{c}\mathrm{wt}\left(x^5+x^9\right)+\mathrm{wt}\left(x^4+x^{10}\right)+\mathrm{wt}\left(x^6+x^8\right)\\ \mathrm{wt}\left(x^{11}+x^{13}\right)+\mathrm{wt}\left(x^{10}+x^{14}\right)+\mathrm{wt}\left(x^6+x^8\right)\\ \mathrm{wt}\left(x^{13}+x^{11}\right)+\mathrm{wt}\left(x^{10}+x^{14}\right)+\mathrm{wt}\left(x^4+x^{10}\right)\\ \mathrm{wt}\left(x^{13}+x^{11}\right)+\mathrm{wt}\left(x^{11}+x^{13}\right)+\mathrm{wt}\left(x^5+x^9\right)\end{array}\right\}={\min }^{+}\left\{6,6,6,6\right\}=6$

Thus, the additional check performed by the processor 101 in block 621 of FIG. 6b would show that for the two examples above the first code is better than the second code and that, consequently, the second code would be discarded.

In a processing block 623 of FIG. 6b the processor 101 is configured to perform the same selection as described in the context of block 611 of FIG. 6a.

In a processing block 625 of FIG. 6b the processor 101 is configured to perform an exact calculation of the minimum Hamming distance for the remaining code candidates. In an embodiment, the processor 101 is configured to perform this exact calculation on the basis of an algorithm for finding the minimal distance in a lattice, as will be described in more detail in the following. In other words, in an embodiment the processor 101 is configured to determine real code distances using number theory.

The rows of a parity check matrix H can be considered as vectors b_i. Let L(b₀, b₁, . . . , b_n−1)={Σ_i=0ⁿ⁻¹x_ib_i:(x₀, x₁, . . . , x_n−1)∈Zⁿ} be a lattice over the vectors b_i(n=CL−1). The processor 101 is configured to determine the minimum distance between vertices of this lattice and to determine minimum Hamming distance for H on the basis thereof.

In an embodiment, the processor 101 is configured to generate a lattice based on a code C(H) such that the minimal non-zero lattice vector corresponds to the minimal Hamming distance vector in the code.

In a first stage, the processor 101 is configured to choose a scaling factor N with

$N\ge \lceil {\gamma }_{\beta }^{\frac{n-1}{\beta -1}}2\sqrt{\left(m+1\right)\left(n+1\right)}r_{\max }M^m\rceil ,$

• • where γ_β denotes the Hermite constant, β denotes the maximal degree of block Korkin-Zolotarev method reduction that we will be described in more detail further below, r_max denotes the determined good upper bound for the minimal distance of the lattice based on previous steps of this algorithm with smaller β, and M=max(∥A₀∥, ∥A₁∥, . . . , ∥A_n−1∥, ∥d∥).

In a second stage, the processor 101 is configured to construct the lattice Λ (B_c) on the basis of the matrix

$B_c=\left(\begin{array}{cc}N·H^{\prime }& N·{\mathrm{qE}}_{n-k}\\ E_k& 0\end{array}\right),$

• • wherein H′ denotes the generator matrix for the code C(H) and E_k denotes the identity matrix of size k. If one encoded vector H′c₁ has more ones than another encoded vector H′c₂, i.e. ∥H′c₁∥₁<∥H′c₂∥₁, then the following relation holds for the Euclidian distance: ∥B_cc₁∥₂<∥B_c c₂∥₂ (for N being large enough). For this reason, it is possible for the processor 101 to find the minimal distance vector νϵ{Λ(B_c)\Ø} with ∥ν∥_∞=1, which, in turn, provides the minimum Hamming distance of the code C(H).

In an embodiment, the processor 101 is configured to use a Gram-Schmidt orthogonalization process. In an embodiment, the processor 101 is configured to generate an orthogonal basis using the following equations:

$\begin{array}{c}{b}_0^{\perp }=b_0,\\ b_1^{\perp }=b_1-{\mu }_{0,1}b_0,\\ \dots \\ b_{n-1}^{\perp }=b_{n-1}-\sum _{i=0}^{n-2}{\mu }_{i,n-1}b_0,\end{array}$ $\mathrm{where}{\mu }_{i,j}=\frac{〈b_i,b_j〉}{〈b_j,b_j〉}.$

Ordered by length basis B={b₀, b₁, . . . , b_n−1} of lattice L⊂^m is adducted by block Korkin-Zolotarev method with block size β∈[2, m] and precision

$\delta \in \left(\frac{1}{2};1\right],$

if:

• • Basis B adducted by length (|b_i|≤|b_j|iff i>j)
  • δ²·∥b_i^⊥∥²≤λ₁²(L_i),i∈{0, . . . , m−1}, where λ₁(L_i)—length of shortest vector in the lattice L_i, in the orthogonal space with basis b_i, . . . , b_{min(i+β−1,m−1)}.

On the basis of the definitions above, the algorithm implemented in the processor 101 for constructing a basis adducted by block Korkin-Zolotarev method can be defined by the following pseudo code:

Input:B={b₀,b₁, . . . , b_n−1}∈[0,1]ⁿ,δ∈(½;1],β∈[2,m]

1. Start same algorithm with lower values of β.
2. Z:=0; j:=0
3. WHILE z<m-1 DO
a. j:=j+1; k:=min(j+ β − 1, m)
b. IF j=m THEM j:=0; k:=β
c. A=|bj|
d. bjnew  = find_minimal_vector(k, {bj, bj+1, ..., bj+k−1},A)
e. h:=min(k+1,m)
f. IF δ |bj| >|bjnew| THEN bj :=bjnew; z := 0 ELSE z:=z+1

Output: B

In an embodiment, the processor 101 is configured determine for given k, B, A the shortest vector of the lattice L_i,k=Σ_i=0^k−1x_ib_i+j:(x₀, x₁, . . . , x_k−1)∈Z^k} spanned over the vectors b_j. In an embodiment, the corresponding algorithm implemented in the processor 101 can work in a parallel mode with several nodes up to A (upper bound for minimal distance). The algorithm, which according to an embodiment is implemented in the processor 101 and is defined by the following pseudo code, is basically an n-fold cycle with calculated start and end for each cycle and a reduction of the upper bound A for each recorded distance.

Input:j,k,B={b₀,b₁, . . . , b_k−1}∈[0,1]^k,id−id of the node.

1. Calculate B⊥ = {b0⊥, b1⊥, . . . bk−1⊥} and matrix μi,j
2. X = {id,0,0, . . . 0}; l = {0}m, R = {Ø};
3. i:=0
4. WHILE i ≤ k:
   a. li = (xi + Σj=i+1mxjμj,i)2 ∥bi⊥∥2
   b. IF (Σj=i+1k−1lj > A) THEN i:=i+1; xi = xi +1
   c. IF (Σj=i+1k−1 lj ≤ A) AND i=0 THEN
      i. IF ∥Σj=0k−1xjbj∥ < A THEN
      A = ∥Σj=0k−1xjbj∥, R = R ∪ {Σj=0k−1xjbj}
   d. IF (Σj=i+1k−1 lj ≤ A) AND i>0 THEN
      i. i:=i−1,
      ii                      .                                                                                                                                        x                        i                                                              =                                          ⌈                                                                        -                                                                                    ∑                                                              j                                =                                                                  i                                  +                                  1                                                                                            m                                                                                                                                                  x                                j                                                                                                                          μ                                                                  j                                  ,                                  i                                                                                                                                                                    -                                                                                                            A                              -                                                                                                ∑                                                                      j                                    =                                                                          i                                      +                                      1                                                                                                        m                                                                                                                                  l                                  j                                                                                                                                                                                                                                                                      b                                i                                ⊥                                                                                                                    2                                                                                              ⌉

• • 5. Return element from R with smallest norm.

In a processing block 627 of FIG. 6b the processor 101 is configured to determine one or more stopping sets on the basis of the following algorithm. A stopping set of size s is a subset {tilde over (V)}={ν_i0, ν_i1, . . . , ν_is−1} of the variables nodes such that the induced subgraph T({tilde over (V)}) has no check nodes of degree one. A constraint set F, is a set {(p_i,s_pi):s_pi∈{0,1}∀p_i∈Γ, where Γ⊆{0, . . . , n−1} (n=WN) is a set of distinct codeword positions. Let χ(F)={p_i:(p_i,1)∈F}, i.e. the support set of the constraint set F. H_A denotes the parity-check matrix consisting of columns from H corresponding to indices from the set A⊆{0, . . . , n−1}, and with the all-zero columns with indices from Γ\A. The row of the parity-check matrix is active, if the row weight is exactly one. The set of indices of active rows in H is ϕ(H). The support set χ(x) of vector x∈{0,1}ⁿ is the set of indices of non-zero elements of x, where there are no active rows, i.e. |ϕ(H)|=0. S⊆{0,1}ⁿ denotes the set of all length-n binary vectors and S^(F)=(s₀, . . . , s_n−1)∈S:s_j=s if (j, s)∈F. S_H denotes the unique maximum subset of {0,1}ⁿ such that for every element s∈S_H, with support set χ(s). The constraint set F is valid if and only if S_H^F=(S_H)^F is non-empty. The weight function w(F) is the Hamming weight of (S_H)^F when F is valid and infinity is F is not valid (which is a way to obtain trapping sets subgraph). W′(F) is any lower bound of W(f).

In an embodiment, the processor 101 is configured to determine one or more stopping sets on the basis of a branch-and-bound method. There are 2^WL possible values of a coding vector of length WL. In an embodiment, this set of all possible values is split into branches by adding constraints of the kind x_i=k. In an embodiment, the processor 101 is configured to determine all stopping sets of length r or less on the basis of a branch-and-bound method, as defined by the following pseudo code:

• • 1. Generate initial list of constraints sets L from one element-empty constraint set F={ }.
  • 2. Split constraint set. Take first constraint F from list L. Most general and simple constraint set F={ }. Every constraint set F can be split into two, by any variable x_i, F₂=F∪{x_i=0} and F₂=F∪{x_i=1}. Replace constraint set F in the list L into two new constraints sets F₁ and F₂.
  • 3. Repeat the following steps 4 to 6 for each constraints set F₁ and F₂.
  • 4. Extend constraints set. Perform extended iterative decoding with achieve some values of x_i∉F_k. Add these values as additional constraints to F_k. In case the extension of the constraints set leads to contradictory results, the constraint set can be eliminated.
  • 5. Find new stopping sets. If constraint F_k has all fixed variables, i.e. corresponds to a single point, check whether it has number of 1 equal or less than τ, add χ(F_k) to list of the stopping sets already found.
  • 6. Bound part, eliminate branch. Calculate lower bound w′(F) of minimal stopping set. If w′(F)>τ, eliminate F_k.
  • 7. If L is not empty return to step 2.

In an embodiment, the processor 101 is configured to determine a lower bound of the minimal stopping set for the constraint set F in the following way. Let q denote the number of constraints x_i=1 in the constraint set F. Let T(F) denote the set of columns, whose indices are not empty and are not used in the constraint set F. Let {tilde over (H)} denote a submatrix of H consisting of columns from the set T(F). It has been shown that the following linear lower estimation holds:

$w^{\prime }\left(F\right)=q+\underset{x_i\ge 0}{\min }\sum _{i=0}^{T\left(F\right)-1}x_i,\mathrm{when}\tilde{H}x\ge {\left(1,\dots ,1\right)}^T$

In an embodiment, the processor 101 is configured to compute the above lower bound using linear optimisation.

In a processing block 629 of FIG. 6b the processor 101 is configured to estimate a pseudo code weight of a trapping set in the following way. To enumerate trapping sets an approach simulating a belief propagation algorithm with deterministic noise of specific tree-like shapes can be used by the processor 101. It is assumed that the girth of the graph is larger than 4. Consider some variable “root” node in the Tanner graph as well as three variable nodes at a distance of 2 from this root node. A minimal tree containing these 4 variable nodes is a 4VN subgraph. These 4VN subgraphs satisfy the following two important properties:

• • Each trapping intersects by 3 variable vertices with at least one such 4VN subgraph. Three variable vertices are in the cycle and one variable node is connected to the cycle via a check node.
  • The number of 4VN subgraphs is relatively small and possible to enumerate. The number of these variants is bounded by n (d_c−1)^dν, where n=WN denotes the number of variables, d_ν denotes the weight of the column (for irregular codes maximal weight of the column), and d_c denotes the weight of the row.

FIG. 9 shows a schematic diagram illustrating an exemplary 4VN subgraph of a protograph.

Using a 4VN subgraph specific noise can be constructed for belief propagation algorithm (Sum-product). As the code is linear, without loss of generality it can be assumed that the sent data is all-zeros and decoded ‘1’ corresponds to mistakes, positive LLR corresponds to ‘1’ and negative to ‘0’.

The noise measured in LLR is constructed by putting k(1−ε₁) into 4 variable nodes for a given 4VN subgraph, and for all other variable nodes kγ is chosen, where k is the cannel factor, and ε₁, γ denote manually chosen parameters.

Constants are chosen to obtain the situation that an error causes only a small number of unsatisfied parity checks. The channel factor k has the same meaning as in the normal decoding process, i.e. it is a factor used to convert received signal to the log-likelihood values. More precisely, for an AWGN channel with variance σ², the channel factor is 2/σ².

The constant γ can be chosen to be less than 1 to “weaken” the graph not affected by an error impulse. Preferred values for γ range from 0.3 to 0.8 depending on a graph. The error magnitude E can be chosen empirically large enough to provoke errors in the trapping sets.

For each described above error impulse the processor 101 is configured to start the decoding process. Denote by x_i the hard decision after i iterations (it is assumed that the processor 101 performs at most i_max iterations). Find the number of stem, when the number of unsatisfied parity checks is minimal:

$i^{*}=\underset{1\le i\le i_{\max }}{\mathrm{argmin}}w_H\left(Hx_i\right).$

Let S(x) be a set of variable nodes whose corresponding bits in the vector x are 1.

Then a subgraph included by S(x_i*) is considered as a trapping set. If S(x_i*) is not a trapping set, the processor 101 tries growing each S(x_i),

$\frac{k_{\max }}{2}\le i\le k_{\max }$

into a trapping set. To this end, the processor 101 is configured to determine a minimal set S′ (x_i)⊃S(x_i) which contains at least one cycle. Thereafter, the processor 101 is configured to find a minimal set S″(x_i)⊂S′(x_i), which contains the same cycles as the set S′ (in other words, does not contain any tree like structures). The processor 101 provides S″(x_i) as the trapping set for x_i.

In an embodiment, the apparatus 100 can maintain a list of all trapping sets found, in particular of the recently determined trapping sets. In an embodiment, this list of trapping sets is maintained by the apparatus in a lexicographic order, i.e. T′<T′ if f T₁′<T₁″ or T₁′=T₁″ and T₂′<T₂″. In an embodiment, the apparatus 100 is configured to delete the last trapping set on the list, if the list of trapping sets becomes too large.

FIG. 10a shows a diagram illustrating the performance of codes provided by embodiments of the invention in comparison with conventional codes. More specifically, FIG. 10a shows a comparison of the performance of N=28980, R=0.879 LTE with 8 iteration max-log-map, two families of binary SC-LDPC codes which use a base matrix: regular code with column weight 3, circulant 230 and irregular RA with average column weight 3.57 and circulant 57 under 30 iterations of layered min-sum and NB GF(64) QC-LDPC based on expander graph under 30 iteration QSPA-FFT, QAM-64.

FIG. 10b shows a diagram illustrating the performance of codes provided by embodiments of the invention in comparison with conventional codes. More specifically, shows a comparison of the performance of N=44160, R=0.6 LTE with 8 iteration max-log-map, two binary SC-LDPC codes which use base matrix: regular code with column weight 3, circulant 320 and irregular RA with average column weight 3.57 circulant 138 under 30 iterations of layered min-sum, QAM 256.

As can be taken from FIGS. 10a and 10b, tail-biting SC-LDPC codes provided by embodiments of the invention show good performance in the “waterfall″” region, have a hardware friendly decoder (every repetition uses the same code, moreover a window decoder can be used to get more convolutional gain with constant latency) and an encoder of reasonable complexity using CPM Gaussian elimination approach, as provided by embodiments of the invention.

FIG. 11a, 11b shows a diagram illustrating the performance of Multi-edge LDPC codes provided by embodiments of the invention in comparison with known codes from recent 3gpp proposals, namely Codes A and Codes B. More specifically is shows a comparison of the SNR required for codes with rates ½ and 0.89 for an information length in the range from K=100 to 8000 to reach a Frame Error Rate 10⁻² under 15 iteration of layered normalized min-sum, QPSK.

Embodiments of the invention provide on the basis of a QC-LDPC protograph a block version of a convolutional code, namely a tail-biting spatially-coupled (SC) LDPC code. Embodiments of the invention allow generating a code with SC-LDPC structures of the graph using a Belief Propagation with the following properties: large Hamming distance (code properties), better structures of cycles (graph properties ACE Spectrum when ACE=EMD) and reasonable complexity (average column weight, size of base matrix, maximal column weight).

While a particular feature or aspect of the disclosure may have been disclosed with respect to only one of several implementations or embodiments, such feature or aspect may be combined with one or more other features or aspects of the other implementations or embodiments as may be desired and advantageous for any given or particular application. Furthermore, to the extent that the terms “include”, “have”, “with”, or other variants thereof are used in either the detailed description or the claims, such terms are intended to be inclusive in a manner similar to the term “comprise”. Also, the terms “exemplary”, “for example” and “e.g.” are merely meant as an example, rather than the best or optimal. The terms “coupled” and “connected”, along with derivatives may have been used. It should be understood that these terms may have been used to indicate that two elements cooperate or interact with each other regardless whether they are in direct physical or electrical contact, or they are not in direct contact with each other.

Although specific aspects have been illustrated and described herein, it will be appreciated by those of ordinary skill in the art that a variety of alternate and/or equivalent implementations may be substituted for the specific aspects shown and described without departing from the scope of the present disclosure. This application is intended to cover any adaptations or variations of the specific aspects discussed herein.

Although the elements in the following claims are recited in a particular sequence with corresponding labeling, unless the claim recitations otherwise imply a particular sequence for implementing some or all of those elements, those elements are not necessarily intended to be limited to being implemented in that particular sequence.

Many alternatives, modifications, and variations will be apparent to those skilled in the art in light of the above teachings. Of course, those skilled in the art readily recognize that there are numerous applications of the invention beyond those described herein. While the present invention has been described with reference to one or more particular embodiments, those skilled in the art recognize that many changes may be made thereto without departing from the scope of the present invention. It is therefore to be understood that within the scope of the appended claims and their equivalents, the invention may be practiced otherwise than as specifically described herein.

Claims

1. An apparatus for providing a parity check matrix defining a spatially-coupled low density parity check, QC-LDPC, code on the basis of a set of base matrix parameters defining a plurality of base matrices, each base matrix of the plurality of base matrices being associated with a protograph of a plurality of protographs, wherein the set of base matrix parameters defines the size W×C, a circulant size N, a maximal column weight M and a set of allowed column weights of the plurality of base matrices, wherein the apparatus comprises: a processor configured to:generate on the basis of a plurality of protographs a set of candidate protographs by discarding protographs of the plurality of protographs;lift the protographs of the set of candidate protographs for generating a plurality of codes; andgenerate on the basis of a plurality of codes a set of candidate codes by discarding codes of the plurality of codes,wherein the processor is configured to lift the protographs of the set of candidate protographs on the basis of a simulated annealing technique.

2. The apparatus of claim 1, wherein the processor is configured to discard those protographs of the plurality of protographs that are associated with a LDPC code having a minimum Hamming distance that is larger than a minimum Hamming distance threshold value.

3. The apparatus of claim 2, wherein the processor is configured to estimate the minimum hamming distance of a LDPC code C on the basis of the upper bound defined by the following equation:

4. The apparatus of claim 2, wherein the minimum Hamming distance threshold value is (C+1)!.

5. The apparatus of claim 3, wherein the minimum Hamming distance threshold value is (C+1)!.

6. The apparatus of claim 2, wherein the processor is further configured to discard protographs of the plurality of protographs on the basis of the balanced girth of the parity check matrix H associated with each protograph.

7. The apparatus of claim 3, wherein the processor is further configured to discard protographs of the plurality of protographs on the basis of the balanced girth of the parity check matrix H associated with each protograph.

8. The apparatus of claim 4, wherein the processor is further configured to discard protographs of the plurality of protographs on the basis of the balanced girth of the parity check matrix H associated with each protograph.

9. The apparatus of claim 6, wherein the processor is configured to discard those protographs from the plurality of protographs that are associated with a parity check matrix H having a balanced girth which is larger than a balanced girth threshold value.

10. The apparatus of claim 7, wherein the processor is configured to discard those protographs from the plurality of protographs that are associated with a parity check matrix H having a balanced girth which is larger than a balanced girth threshold value.

11. The apparatus of claim 2, wherein the processor is further configured to lift a protograph of the plurality of protographs having at least one parallel edge to a protograph having no parallel edges, in particular using a quasi-cyclic technique.

12. The apparatus of claim 3, wherein the processor is further configured to lift a protograph of the plurality of protographs having at least one parallel edge to a protograph having no parallel edges, in particular using a quasi-cyclic technique.

13. The apparatus of claim 4, wherein the processor is further configured to lift a protograph of the plurality of protographs having at least one parallel edge to a protograph having no parallel edges, in particular using a quasi-cyclic technique.

14. The apparatus of claim 2, wherein the processor is further configured to discard those protographs of the plurality of protographs that are associated with an extrinsic message degree (EMD) that is smaller than an EMD threshold value.

15. The apparatus of claim 3, wherein the processor is further configured to discard those protographs of the plurality of protographs that are associated with an extrinsic message degree (EMD) that is smaller than an EMD threshold value.

16. A method for providing a parity check matrix defining a spatially-coupled low density parity check, LDPC, code on the basis of a set of base matrix parameters defining a plurality of base matrices, each base matrix of the plurality of base matrices being associated with a protograph of a plurality of protographs, wherein the set of base matrix parameters defines the size W×C, a circulant size N, a maximal column weight M and a set of allowed column weights of the plurality of base matrices, wherein the method comprises: generating on the basis of the plurality of protographs a set of candidate protographs by discarding protographs of the plurality of protographs;lifting the protographs of the set of candidate protographs for generating a plurality of codes; andgenerating on the basis of the plurality of codes a set of candidate codes by discarding codes of the plurality of codes,wherein the step of lifting the protographs of the set of candidate protographs is based on a simulated annealing technique.

17. The method of claim 16, wherein the method is configured to discard those protographs of the plurality of protographs that are associated with a LDPC code having a minimum Hamming distance that is larger than a minimum Hamming distance threshold value.

18. The method of claim 17, wherein the method is configured to estimate the minimum hamming distance of a LDPC code C on the basis of the upper bound defined by the following equation:

19. The method of claim 17, wherein the minimum Hamming distance threshold value is (C+1)!.

20. A computer program comprising program code for performing the method of claim 16 when executed on a computer.