Advances in Wireless Communication 课堂笔记（上）

Basics of error-correcting codes

Generation of wireless communications

Gneration	time	technic	max speed
1G	early 1980’s	Analog, FM	12kbps
2G	1991	digital, TDMA	50kbps~1Mbps
3G (include UMTS & CDMA 2000 & 3GPP)	1998	CDMA	20Mbps
4G (LTE)	2008	OFDM	1Gbps
5G	2020		up to 10Gbps

communication system

channel is characterized by the transition probabilities
P r { Y = y   ∣   X = x }   f o r    a n y    x ∈ X ,   y ∈ Y x = { 0 , 1 } , y = R Pr\{Y=y \,| \,X=x\} \,for\,\, any\,\, x\in X, \, y \in Y\\ x=\{0,1\},y=R Pr{Y=y∣X=x}foranyx∈X,y∈Yx={0,1},y=R
in the case of continuous y, we use condition pdf

Channel model

1. BSC: binary symetric channel
   
   capacity: bit per channel use, $1-h_2(p)$, $h_2()$ is a function

2. BEC: binary erasure channel
   
   capacity: $1-\epsilon$

3. AWGN: ADDITIVE WHITE Gaussian Noise channel
   
   x ∈ { − 1 , + 1 } , b i n a r y , o r    c o n t i n u o u s    x = R x\in \{-1,+1\}, binary, \\ or\,\, continuous\,\, x=\reals x∈{−1,+1},binary,orcontinuousx=R
   x is subject to power constrain $E[X^2]=P$
   P is power of transistor
   capacity: $\frac{1}{2}lg(1+SNR)=\frac{P}{{\delta }^2}$
   also $Wlg(1+SNR)$ W:bandwidth

4. Rayleigh fading channel
   $$x\in Xy\in \mathbb{R}y=ax+n$$ a: RV, obey Rayleigh distribution with scalar parameter ${\tau }^2$
   $n\sim \mathcal{N}(0,{\delta }^2)$

code design

Code: s structured subset of an ambient set, collection of all codewords.
Encoder: A mapping between the set of message and the set of codewords.
Decoder: Given an elementary $\in A$, (y is the received symbol or a sequence of such y’s), find the “most likely” codeword/message.

m: message
c: codeword
C: code
Minimize the prob of error P r { m ˆ ≠ m } Pr\{\^{m}\not = m\} Pr{mˆ=m} through structure of code

A natural structure with algebraic strutures to play with a linear subspacce to an ambient vector.

A linear code C of dimension k in A, here, $F^n$ is field: 0, 1

Each element in $c\in C$ is represented as a vector of length n, $c=(c_1,c_2,c_3,...,c_n),c_i\in F$, c is binary sequence, n is the length of the code.

$(n,k)$ code,n is block length, k is dimension of code, $k\le n$

Example:
Let c be an $(n,n-1)$ linear code as follows

c is one-parity code.

rate: bit per channel/symbol use

Rate of a code C of length n over an alphabet of size $q$:$$\begin{gathered} rate(C)=\frac{lo{g}_q|C|}{n}{|}_{|C|=q^k}=\frac{k}{n} \\ {q}^k:sizeofthecodeofdimensionk \\ q:possiblenumberofcodes \end{gathered}$$

Hamming distance $d_H(x,y)$
$d_H(x,y)$=number of positions(bits) in which $x$ and $y$ differ
$x:$transmitted , $y:$received

properties:

1. $d_H(x,y)\ge 0$
2. $d_H(x,y)=0⟺x=y$
3. $d_H(x,y)=d_H(y,x)$
4. triangle inequality: $d_H(x,z)\le d_H(x,y)+d_H(y,z)$

Hamming weight: number of non-zero entries of $\vec{x}$
Hamming weight at a vector $\vec{x}$: $w_H(x)=d_H(x,0)$
$0:zerocode$

Minimum distance of a code
$d_{min}(c)=$ $\genfrac{}{}{0ex}{}{min}{\genfrac{}{}{0ex}{}{x,x^{\prime }\in c}{x\ne x^{\prime }}}$$d_H(x,x^{\prime })$

for linear code C, the $d_{min}(c)=$ $\genfrac{}{}{0ex}{}{min}{\genfrac{}{}{0ex}{}{c\in C}{c\ne 0}}$$w_H(c)$

if we want to find the minimum distance, just need to find the minimum distance of non-zero codeword to the all-zero codeword.

Theorem: (worse case guarantee) Let $d=d_{min}(c)$, then c can correct up to $|\frac{d-1}{2}|$ errors.

Approach to design code

Construct codes with maximum distance, give a certain rate (or length an size)
Algebraic codes: Turbo Code (3G/4G used), LDPC and polar codes (in 5G)

linear code approach
Consider a basis for an (n,k) linear code C, which cover field $F$, denoted by $c_1,c_2,...,c_k$ c = { λ 1 c 1 + λ 2 c 2 + . . . + λ k c k   ∣   λ i ∈ F } c=\{ \lambda_1c_1+\lambda_2c_2+...+\lambda_kc_k\, |\,\lambda_i\in F \} c={λ1​c1​+λ2​c2​+...+λk​ck​∣λi​∈F}
Let $G={\left[\begin{array}{c}{c}_1\\ c_2\\ ...\\ c_k\end{array}\right]}_{k\times n}$ , a generator matrix
for the code c
$c=({\lambda }_1,{\lambda }_2,...,{\lambda }_k)\times G$
c = { V G ∣ V ∈ F k } , V : m e s s a g e    m a t r i x c=\{VG | V\in F^k\}, V:message\,\, matrix c={VG∣V∈Fk},V:messagematrix
the generator matrix is not unique

encoding mapping: $V\to VG$
$V$:message of length $k$, $k$ bit
$VG$:encoded codeword

example:
one parity check code$$(x_1,x_2,...,x_{n-1})\to (x_1,x_2,...,x_{n-1},\sum _{i=1}^{n-1}{n}_i)$$

(the left region of the dash line can be any number)

systematic encoder: every encoded codeword contains the original message as follows:
message=$(u_1,u_2,...,u_k)$, codeword=$(u_1,u_2,...,u_k,x_{k+1},...,x_n)$
so $G={\left[\begin{array}{c}{I}_{k\times k}|A_{k\times (n-k)}\end{array}\right]}_{k\times n}$
no matter what matrix A is.

Theorem: Every linear code has a systematic encoder up to a permittion on the code bits, which can design generator matrix

For a code C with generator matrix $G_{k\times n}$ let $H_{(n-k)\times n}$ denote the kernel of $G_{k\times n}$, $G{H}^T=0_{k\times (n-k)}$
all rows of G are orthogonal to all rows of H
H: the parity-check matrix for c

Note: In binary field, non-zero vectors can be self-orthogonal. Any binary vector are even Hamming weight is self-orthogonal.

Example:
For on-parity check code C, C with $G_{(n-1)\times n}H=[1,1,...,1{]}_{1\times n}$. In general, for a systematic $$G={\left[\begin{array}{c}{I}_{k\times k}|A_{k\times (n-k)}\end{array}\right]}_{k\times n}$$we have$$H=[-A^T|I_{(n-k)\times (n-k)}{]}_{(n-k)\times n}$$

Example:
Let C be a binary linear (6, 3) code with the generator matrix$$G=\left[\begin{array}{c}101101\\ 010110\\ 001001\end{array}\right]$$
a. Find a systematic generator matrix for C.
systematic form:$$G_{sys}=\left[\begin{array}{c}100100\\ 010110\\ 001001\end{array}\right]$$
b. Find a parity-check matrix for C.
$$\begin{gathered} G_{sys}={\left[\begin{array}{c}{I}_{k\times k}|A_{k\times (n-k)}\end{array}\right]}_{k\times n} \\ H=[-A^T|I_{(n-k)\times (n-k)}{]}_{(n-k)\times n} \\ H=\left[\begin{array}{c}110100\\ 010010\\ 001001\end{array}\right] \end{gathered}$$
c. What is the minimum distance of C?
The minimum distance is at least two, since there is no zero column in $H$
And we do have a codeword of weight 2(the third row of $G$), $d_{min}(C)=2$

Lemma properties: let c be a linear (n,k) code, with parity-check matrix H, then we have $c\in C⟺H{C}^T=0$

Graphical model representation of decoding, message passing algorithms

linear Code C

parity check matrix $H_{(n-k)\times n}$
$n$: block length
$k$: # of information bit$$c\in C\iff H{C}^T=0$$
each row of H is parity checkequation

For any $y\in F$, the syndrome of $y$ with respect to the code C with its parity check matrix H is define as $H^y$, syndrome of y.
$H{y}^T$: matrix ,size $(n-k)\times 1$
number of possible symdroms:$2^{n-k}$

$H(a_i+c_j{)}^T=H{a}_i^t+H{c}_j^t$
where $H{c}_j^t=0$

Let $S_1,S_2,...,S_{2^{n-k}}$ denote all possible syndromes, also let $a_i$ be the minimum weight vector with $H{a}_i^{+}=S_i$

Coset leader	standard array	syndromes
$a_1$	$a_1+c_1...a_1+c_{2^k}$	$S_1$
$a_2$	$a_2+c_1...a_2+c_{2^k}$	$S_2$
$...$	$...$
$a_{2^{n-k}}$	$a_{2^{n-k}}+c_1...a_{2^{n-k}}+c_{2^k}$	$S_{2^{n-k}}$

$c_1,c_2...,c_k$denote all the code words, so standard array is the possible y that can be received.

Syndrome decoding - only bitflip error

$y$ :received vector (binary)

1. compute the syndrome of $y$ - $H{y}^T$
2. locate $S_1=H{y}^T$ in the standard array with coset leader $a_i$
3. output codeword $c=y-a_i$, $a_i$:error pattern

The syndrome decoder is a minimum distance decoding, which mapping $y$ to teh closest codeword. Let $d_{min}(C)=d$, Then all binary vector of weight up to $|\frac{d-1}{2}|$ will be among coset leaders

Maximum likelihood decoder

consider a BSC(P ), P<0.5

P r { r e c e i v i n g    y    ∣    c    i s    t r a n s m i t t e d } Pr\{receiving\; y \;| \;c\; is\; transmitted\} Pr{receivingy∣cistransmitted}
$w=w_H(y-c)$, number of position in which $y$ and $c$ are different, $w=p^w(1-p{)}^{n-w}=(\frac{p}{1-p}{)}^w(1-p{)}^n$
ML decoder$\iff$ maximize the probability P r { y ∣ m i n ( c ) } Pr\{y | min(c)\} Pr{y∣min(c)} $\iff$minimize $w$ $\iff$ minimize distance decoder $\iff$ syndrome decoder

for BSC, these decoder are the same

Note that ML decoding has exponential (in n) complexity
Also syndrom decoding needs to search with in an array of exponential size $\Rightarrow$ exponential complexity

LDPC Code: A low-density parity check code is a binary, linear block code for which the parity-check mtrix is sparse. (both row and coloum be sparse in terms of # of 1’s)

A regular LDPC code, has an equal # of 1’s in each row $w_r$ and equal # of 1’s in each colum $w_c$

Note that $w_c\cdot n=w_r\cdot m$ for $H_{m\times n}$

with $m\ge n-k$ for an (n,k) code, this code is refer to as a ($w_c,w_r$) regular LDPC code $$

Example:
A (2,4) regular LDPC code ,n=10, m=5, k=6, $w_c=2$, $w_r=4$
$$H={\left[\begin{array}{cccccccccc}1& 1& 1& 1& 0& 0& 0& 0& 0& 0\\ 1& 0& 0& 0& 1& 1& 1& 0& 0& 0\\ 0& 1& 0& 0& 1& 0& 0& 1& 1& 0\\ 0& 0& 1& 0& 0& 1& 0& 1& 0& 1\\ 0& 0& 0& 1& 0& 0& 1& 0& 1& 1\end{array}\right]}_{5\times 10}$$ $rank(H)=n-k=4,k=n-rank(H)$

Gallager’s early work, Gallager’s decoder

There exists a sequence of LDPC codes(regular) with increasing length and positive rate $k/n>0$, positive $d_{min}/n>0$

Gallager’s decoder(hard-desicion bit flipping decoder)

1. fix a threshold S (to be optimized)
2. compute the syndrome bits $S_j$’s,
   $$H{y}^T=\left[\begin{array}{c}{S}_1\\ S_2\\ ...\\ S_m\end{array}\right]y^T=\left[\begin{array}{c}...\\ i-th\\ ...\end{array}\right]$$
   y is received vector
3. of all $S_j$’s are 0, then stops
4. otherwise bit i, i=1, 2, …, n
   $g_i$: number of non-zero syndroms that involve the i-th bit
5. A = { i = g i > S } A=\{i=g_i>S\} A={i=gi​>S}
6. flip bit i for all i in A and back to step 2

Belief propagation Algorithm

Belief propagation (BP) is a type of message passing algorithm. It uses a Tanner graph representation of the code (A bi-partite graph)
one part: A node for each information bit (variable node), in other part A check node for each parity
There is an edge connection f to $x_i$ if the (i,j) entry in matrix H is one

for instane over AWGN, $y_i=(2x_i-1)+n_i,n_i\sim \mathcal{N}(0,{\sigma }^2)$

if $f_1$ connect to $x_1,x_2,x_3$, then $x_1+x_2+x_3=0$
$x_i+x_{i^{\prime }}+x_{i^{\prime \prime }}+...=0$

BP algorithm is an iterative decoding algorithm
In each iteration

• Each variable node sends a message to each check node
• each check node sends a message to each variable node
• each variable node update its ‘belief’ about $x_i$

Goal of decoding : compute $P(x_i=0|y_1,y_2,...y_{n}andallparitybitsbeing"0")$
Also called:bit map decoder

$q_{ij}(x)=P(x_i=x|y_i,alltheextrinsicinformationpassedto{x}_{i}from{f}_j)$
$r_{ji}(x)=P(paritybit{f}_{j}issatisfied|x_i=x,otherbits{X}_{i^{\prime }}^{\prime }sconnectedto{f}_j(otherthan{X}_i)aredistributedwith{q}_{i^{\prime },j})$

How to compute $q,r$
initialization: q i , j ( x ) = P ( X i = x   ∣   Y i = y i ) ,    x ∈ { 0 , 1 } q_{i,j}(x)=P(X_i=x\,|\,Y_i=y_i),\;x\in \{0,1\} qi,j​(x)=P(Xi​=x∣Yi​=yi​),x∈{0,1}

ratio $\frac{P(X_i=0|Y_i=y_i)}{P(X_i=1|Y_i=y_i)}$ is likelihood ratio for making decision. In practice, we work with the log(likelihood ratio) LLR, if LLR is positive, ratio>1, $x_i=0$

Notations:
$P_i=P(X_i=1|Y_i=y_i)\sim$ $L(X_i)$ in the LLR domain
$R_j\sim$ indices of 1(s) in row j of H
$C_i\sim$ indices of 1(s) in colum i of H
$R_{j\backslash i}\sim$ $R_j$ exclude i (for example, row 1 is [0 1 1 0 1], R 1 \ 2 = { 3 , 5 } R_{1 \backslash 2}=\{3,5\} R1\2​={3,5} )

Lemma: $A=(a_1,a_2,...,a_L)$ of independent binary random variable with $P(a_i=1)=P_i$, Then we have, look at$$\begin{gathered} P(\sum _{i=1}^L{a}_i=0)=\frac{1}{2}+\frac{1}{2}\prod _{i=1}^L(1-2P_i) \\ P(\sum _{i=1}^L{a}_i=1)=\frac{1}{2}-\frac{1}{2}\prod _{i=1}^L(1-2P_i) \end{gathered}$$

message passing:$$\begin{gathered} r_{j,i}(0)=\frac{1}{2}+\frac{1}{2}\prod _{i\in R_{j\backslash i}}(1-2q_{i^{\prime },j}(1)) \\ {r}_{j,i}(1)=1-r_{j,i}(0) \\ \frac{q_{i,j}(0)}{q_{i,j}(1)}=\frac{(1-P_i)}{P_i}\prod _{j^{\prime }\in C_{i\backslash j}}\frac{r_{j^{\prime },i(0)}}{r_{j^{\prime },i}(1)} \\ L(q_{i,j})=log(\frac{q_{i,j}(0)}{q_{i,j}(1)}) \\ L(r_{j,i})=log(\frac{r_{j,i}(0)}{r_{j,i}(1)}) \\ \Rightarrow \{\begin{array}{l}L(q_{i,j})=L(X_i)+{\sum }_{j^{\prime }\in c_{i\backslash j}}L(r_{j^{\prime },i})\\ L(r_{j,i})=2tan{h}^{-1}({\prod }_{i\in R_{j\backslash i}}tanh(\frac{1}{2}L(q_{i^{\prime },j})))\\ updatebeliefof{X}_i{}^{\prime }s{L}_{new}(X_i)=L(x_i)+{\sum }_{j\in c_i}L(r_{j,i})\end{array} \end{gathered}$$

The step also can be written as$$\begin{gathered} {\alpha }_{i,j}=Sign(L(q_{i,j})) \\ {\beta }_{i,j}=|L(q_{i,j})| \\ \varphi (n)=log(\frac{e^n+1}{e^n-1}) \\ \varphi isselfinverse:{\varphi }^{-1}=\varphi \\ L(r_{j,i})=\prod _{i^{\prime }\in R_{j\backslash i}}{\alpha }_{i^{\prime },j}{\varphi }^{-1}(\sum _{i^{\prime }\in R_{j\backslash i}}\varphi ({\beta }_{i^{\prime },j})) \end{gathered}$$
Min-Sum approximation Lapproximate with $\genfrac{}{}{0ex}{}{min}{i^{\prime }\in R_{j\backslash i}}$ ${\beta }_{i^{\prime },j}$, the result smaller than $\genfrac{}{}{0ex}{}{min}{i^{\prime }\in R_{j\backslash i}}$ ${\beta }_{i^{\prime },j}$

offset Min-Sum approximation
$L(r_{j,i})={\prod }_{i^{\prime }\in R_{j\backslash i}}{\alpha }_{i^{\prime },j}($$\genfrac{}{}{0ex}{}{min}{i^{\prime }\in R_{j\backslash i}}$${\beta }_{i^{\prime },j}-\alpha )$
$\alpha$: constant to be optimized per application

Example：
BP decoding with Min-Sum approximation A(2,3) regular LDPC code, $$\begin{gathered} H={\left[\begin{array}{cccccc}1& 1& 1& 0& 0& 0\\ 1& 0& 0& 1& 1& 0\\ 0& 1& 0& 1& 0& 1\\ 0& 0& 1& 0& 1& 1\end{array}\right]}_{4\times 6} \\ n=6,m=4,k=3,w_c=2,w_r=3 \\ rank(H)=3⟹k=6-3=3 \end{gathered}$$
Tunner graph representation
“1” in H matrix means having connection between check node and variable node.

suppose we have $$\begin{gathered} L(X_i)=-1,2,3,-4,4,1 \\ fori=1,2,3,4,5,6 \end{gathered}$$

what is the updated belife of $X_i$ after on iteration of BP with Min-Sum approximation
write down $q_{i,j}$ matching the connection $q_{i,j}=L(X_i)$ (in black, ingnore the arrow point, the $q_{i,j}$ is the message from “circle” to “square”)

find $r_{j,i}$ (number in red)

updated belief $L^{(new)}(X_i)$

complexity:BP can be used (in principle) to decode any linear code given H. For LDPC code of “constant” degree(with respect number), the complexity of each iteration is $O(n)$. Otherwise for a general code it’s $O(n^2)$

The exact LLR calculation (max-product) is rather complex and is often approximated but approximation works well when there are only “a few” terms (in the sum of $\varphi {}^{\prime }s$)

length of the shortest cycle=$2l$, the LLR equations hold up until $l=1$ iterations
Another issue with BP for general code is the Tanner representation is dense $\Rightarrow$ it will have too many short cycles. And short cycles adversely affect the performance of BP, since the independence of $r_{j,i}$'s (for a fixed i) or $q_{i,j}$ (for fixed j) would be violate

• when to stop
  【In practice, after a fixed number of iterations(usually in the range between 5 and 20)
• early stopping
  【Maybe check H to see if parity-check equations are satified after making hard decision s on $X_i$’s (according to update beliefs)
• drawback
  【expensive

CRC: cyclic redundancy check

An $m\times n$ partiy-check matrix, LLR=$log(\frac{P(X_i=0|Y_j^{\prime }s)}{P(X_i=1|Y_j^{\prime }s)})$
if $LLR>0,\widehat{X_i}=0$
if $LLR<0,\widehat{X_i}=1$
this step we called: making the hard decision

matrix $$\left[\begin{array}{c}\widehat{X_1}\\ \widehat{X_2}\\ ...\\ \widehat{X_n}\end{array}\right]$$
if this matrix equals to 0, the decoder is done, output $\widehat{X_i}$ 's
if does not equal to 0, still need to continue
This process is complex - comparable complexity to one iteration of BP DECODING

so we want Alternative solution (to stop), called CRC, cyclic redundancy check.
A few extra bits of redundancy (8,12,16,24) using a cyclic code - an algebraic code.

if CRC= 8 bit, $H^{\prime }={\left[\begin{array}{c}\mathrm{1001..}\\ 01001\\ ....\end{array}\right]}_{8\times n}$

each row of matrix H’ like a cyclic shift, CRC length=$l(8)$

overall H of the code + CRC = ${\left[\begin{array}{c}H\\ H^{\prime }\end{array}\right]}_{(m+l)\times n}$
(n,k)linear code +l bits of CRC, # of information bits = $k-l$

${\left[\begin{array}{c}{H}_{(n-k)\times n}\\ H_{l\times n}^{\prime }\end{array}\right]}_{(n-k+l)\times n}$

we can check CRC equation at the end of each iteration,
if CRC pass: stop the decoder, is CRC not pass: next iteration

At the end of decode , we also check CRC to see if we have read a “valid” codeword" ©
valid codeword: $H{C}^T=0(validcode)H^{\prime }{C}^T=0(validCRC)$
probability of CRC failure=$\frac{1}{2}l$

Transport block

each codeblock has its own CRC
the entive transport block was another CRC

LDPC code over BEC

when decoding over BEC, LLRs do not matter as each coded bit is either known or erased.

$$q_{ij}=\{\begin{array}{ll}{X}_i& \text{if }{X}_{i}isknown\\ e& \text{if }{X}_{i}iserased\end{array}$$

$$r_{ji}=\sum _{i\in R_{j\backslash i}}{X}_i=\{\begin{array}{ll}known& \text{if }all{X}_i(i\in R_{j\backslash i})areknown\\ e& otherwise\end{array}$$

update belief if $X_i$ is erased, $X_i$ is known if at least one of $r_{ji}$'s, $j\in c_i$ is known $\Rightarrow$ $X_i$=known $r_{j,i}$, otherwise it remain erased

Example：






A stopping set is a set of erased, variables that can not be corrected regardless of other variables (even if all others are known)
How this happen?
Let G denote the set of neighbors of the stopping set $V$, then every check node in G is connected to at least two variable node in $V$.
The minimum stopping se $V_{min}$ is the stopping set containing the fewest # of variable node.
Then the code can correct up to $|V_{min}|=1$ erasures $\Rightarrow d_{min}\ge |V_{min}|$ (a code of minimum distance $d_{min}$ can correct up to $d_{min}-1$ erasures)

Density evolution $\to$ over BEC( p)
consider ($w_r,w_c$), regular LDPC code, the probability that a variable node remains erased after the $l$-th iteration (assuming independence $l\le L/2$)

when $l$ is the length of the shortest cycle also refer to as the “girth” of the Tanner graph, denoted by ${\epsilon }_l$

$$\begin{gathered} {\epsilon }_0=P \\ {\epsilon }_l=P\cdot (1-(1-{\epsilon }_{l-1}{)}^{w_r-1}{)}^{w_c-1}forl\ge 1 \end{gathered}$$ $P$: bit $X_i$ is originally erased by channel

$(1-{\epsilon }_{l-1}{)}^{w_r-1}$: the probability that all $X_{i\in R_{j\backslash i}}$ are not erased.
$1-(1-{\epsilon }_{l-1}{)}^{w_r-1}$: the probability that $r_{ji}$ is erased.

Given the degree distribution ($w_r,w_c$) the threshold $\epsilon$ is the maximum p for which ${\epsilon }_l\to 0$ as $l\to \infty$
n large, girth large

Example:
For the (3,6) regular LDPC as $n\to \infty$, we have ${\epsilon }^{\ast }=0.4294$, capacity $=0.5706$, $R=\frac{1}{2}$, low capacity

For (d,2d) regular LDPC codes, ${\epsilon }^{\ast }\to 0.5$ as $l\to \infty$(we can achieve the capacity)
Assuming a random erasurable of all regular (d,2d) LDPC codes, the girth grow large enough as $n$ grows large with probability 1

Note that:

1. Density evolution only describes the asymptotic performance of the Ramdon erasurable of codes.
2. Goal of good H design$$x=\{\begin{array}{l}\text{High girth}\\ \text{High (or almost full) rank}\\ \text{ large minimum stopping set}\end{array}$$

Channel coding techniques in 5G systems

Structure of LDPC in 5G

Protograph LDPC codes: lifting operation using a base matrix

For a lifting operation of size $z$, each check node is replaced by $z$ check nodes (and variable node).
Then each edge in the Tanner graph is replaced by a shifted/performance matrix

it keeps the degree distribution of the Tanner graph (regardless of z)

lifting size : $z$
each entry in the base matrix is a number from -1,0,1,…,$z$
$-1\Rightarrow$ no edges: $z\times z$ of all-zero matrix
$0\Rightarrow$ Identity matrix, for i=1,2,…,$z-1$ shifted permutation matrix by $i$

Example:

There are two types of base graphs/matrixes in 5G LDPC code.
$B_1$ of size 46 $\times$ 68, and $B_2$ of size 42 $\times$ 52.
There are lifting sizes up to 354 maximum block length supported by 5G LDPC is 384 $\times$ 68 = 26112

Polar Code (channel dependence)
channel polarization theory: let W denote the channel BEC§
$w(y|x)$ denotes the probability of receiving $y$ given $x$

$$\begin{gathered} W(0|0)=1-P \\ W(e|0)=P \\ W(1|0)=0 \\ W(1|1)=1-P \\ W(e|1)=P \\ W(0|1)=0 \end{gathered}$$

now consider two channels, the channel that $u_1$ observes and the channel that $u_2$ observes assuming $u_1$ is known

($u_1$ observes)

($u_2$ observes assuming $u_1$ is known)

Given $w^{-}$ is also a BEC, with erasure probability $1-(1-p{)}^2=2p-p^2$, because $u_1$ is known/decoded if and only if both $y_1(=u_1+u_2)$ and $y_2(=u_2)$ are non-erasures $u_1=y_1+y_2=u_1+u_2+u_2=u_1$
$w^{+}$ is also a BEC with erasure probability $p^2$ because $u_2$ is decoded if either $y_1$ or $y_2$ is a non-erasured (if both $y_1$ and $y_2$ are erased, $u_2$ unknown)

Note

1. the sum-capacity is preserved (capacity of BEC( P) is 1-P),
   $c(w^{-})+c(w^{+})=1-2p+p^2+1-p^2=2(1-p)=2c(w)$
2. Also, $2p-p^2>p^2$, for $0<p<1\sim w^{+}$ is better than $w^{-}$

Channel splitting operation

Then $w^{++}$ input $u_4$ output $y_1{y}_2{y}_3{y}_4{u}_1{u}_2{u}_3$
$w^{+-}$ input $u_3$ output $y_1{y}_2{y}_3{y}_4{u}_1{u}_2$
$w^{-+}$ input $u_2$ output $y_1{y}_2{y}_3{y}_4{u}_1$
$w^{--}$ input $u_1$ output $y_1{y}_2{y}_3{y}_4$

This can continue recursively, for $n=2^m$, this is called polarization transform of length $n$ denoted by $p^{(n)}$ recursion stop from $n$ to $2n$

$w^{++...++...}\leftrightarrow w^{(i)}$ by mapping $i-1$ into a binary format of length $m(m=lg(n))$ and replace “1” by “+” and “0” by “-”.

The sum-capacity is preserved: $$\sum _{i=1}^{n}c(w^{(i)})=n\ast c(w)$$
(for symmetric channels)
proof is by chain rule of mutual information assuming input bits $u_i$’s are uniform i.i.d(independent and identically distributed) )

polarization tree

channel polarization: As n grows large, the bit-channels become either completely noiseless (capcacity goes to one) or become completely noise (capacity goes to zero)
(except a vanishing fraction of bit-channels)
further more, the fraction of noiseless channel $\to c(w)$

Example:
BEC(0.5), n=4
Let $z^{(i)}$ denote the erasure prob of $w^{(i)}$

A prove for polarization for BEC
$n=2m$ bit channels $n\cdot c(w)-{\sum }_{i=1}^{n}c(w^{(i)})$
$T_n=\frac{1}{n}{\sum }_{i=1}^n(1-z^{(i)})$
$z^{(i)}$: erasure probability of $w^{(i)}$ $i$-th bit channel
It is sufficient to prove that $\genfrac{}{}{0ex}{}{lim}{n\to \infty }{T}_n=0$

$$z^2(1-z^2)+(2z-z^2)(1-2z+z^2)=2z(1-z)(1-z(1-z))$$
define ${\alpha }_i=z^{(i)}(1-z^{(i)})$
$$\begin{gathered} T_{2n}=\frac{1}{2n}\sum 2{\alpha }_i(1-{\alpha }_i)=\frac{1}{n}\sum {\alpha }_i-{\alpha }_i^2 \\ =\frac{1}{n}\sum {\alpha }_i-\frac{1}{n}\sum {\alpha }_i^2\le T_n-T_n^2 \end{gathered}$$
Lemma:$\frac{\sum {\alpha }_i^2}{n}\ge (\frac{\sum {\alpha }_i}{n}{)}^2$
Note that sequency of { T n } n − 1 \{T_n\}_{n-1} {Tn​}n−1​ positive and strictly decresing $\to \genfrac{}{}{0ex}{}{lim}{n\to \infty }{T}_n$ exists
Let $T_{\infty }=\genfrac{}{}{0ex}{}{lim}{n\to \infty }{T}_n$, $T_{\infty }=T_{\infty }^2-T_{\infty }\Rightarrow T_{\infty }=0$

${\beta }_n=\frac{|i|\epsilon \le z^{(i)}\le 1-\epsilon |}{n}$ for some $\epsilon >0$
Note that $T_n\ge {\beta }_n-\epsilon (1-\epsilon )$
for any fixed of $\epsilon$, ${\beta }_n\to 0$ since $T_n\to 0$

Polarization transform

$$\begin{gathered} x_1=u_1+u_2 \\ {x}_2=u_2\to [x_1{x}_2]=[u_1{u}_2]\left[\begin{array}{c}10\\ 11\end{array}\right]=[u_1{u}_2]G_2 \end{gathered}$$
$$G_{2n}=\left[\begin{array}{c}{G}_n{0}_{n\times n}\\ G_n{G}_n\end{array}\right]=G_n\times G_2=\underset{\text{m times m=log2n}}{\underbrace{G_2⨂G_2⨂G_2⨂...⨂G_2}}=G_2^{⨂m}\text{Kronecker power}$$

Kronecker product of $A_{m\times n}$ and $B_{p\times q}$
$$\begin{gathered} A⨂B={\left[\begin{array}{c}{a}_{11}B..........a_{1n}B\\ ......\\ a_{m1}B..........a_{mn}B\end{array}\right]}_{mp\times nq} \\ {G}_4={\left[\begin{array}{c}1000\\ 1100\\ 1010\\ 1111\end{array}\right]}_{4\times 4} \\ \text{(replacing "0" with "-1" results Hadamard matrix)} \\ \Rightarrow G_n^{-1}=G_{n}or{G}_n\times G_n=I_{n\times n}self-inverse \end{gathered}$$

Encoding complexity

$U_{1\times n}\times G_n$ can be done with $O(nlog(n))$ complexity function $x(1,n)=G_{multiplier}$
$(u(1:n))$

if n==1
	x=u
	return
end
x1=G_multiplier(u(1*n/2))
x2=G_multiplier(u(x/2+1*n))
x=(x1+x2 , x2) 
end

($x_1=...x_2=...$ these two steps can be done in parallel)
($x_1+x_2$ is entry-wise addition)

output of function: $x_{1\times n}=u_{1\times n}{G}_n$
$f(n)$=# of operations to compute this $u_{1\times n}{G}_n$
$=\{\begin{array}{l}f(n)=2f(\frac{n}{2})+\frac{n}{2}\Rightarrow f(n)=\frac{nlg(n)}{2}\\ f(1)=0\end{array}$
latency (time needed, assuming parallelization)
latency of computing $uG$ with the function $G_{multiplier}$
$g(n)$ : the latency, $g(n)=g(\frac{n}{2})+1\Rightarrow g(n)=lg(n)$ (fast enough)

polar code construction

length $n$ dimension $k$, channel $w$
pick the indices of the $k$ “best” bit-channels $w^{(i)}s$ in the polarization transform of length $n$
the genrator matrix for ($n,k$) polar code associated with $w$
from matrix $G_{n\times n}$, select the rows that are indexed by “good” bit-channel

Polar encoder

example:
n=8 k=4 for BEC(0.5)

k=4, pick 4 best one indices 4 6 7 8

$u_{1\times 8}=[000m_{1}0m_2{m}_3{m}_4]$
message bit are $m_1,m_2,m_3,m_4$
$\Rightarrow$ compute $u_{1\times 8}{G}_8$ to get the encoded codeword

Decoder polar code

Successive cancellation decoder
let A denote the set of indices of “good” bit-channels selected fro the code construction, $A=1,2,...,n$ For $i=1,2,...,n$
${\hat{u}}_i$ :decoded version of $u_i$
${\hat{u}}_i$ $\{\begin{array}{ll}0& \text{if }i\in A\\ \text{ML decision of }{u}_i\text{ given }{y}_1,y_2,...,y_n\text{ and }{\hat{u}}_1,{\hat{u}}_2,...,{\hat{u}}_n& \end{array}$

Let probability of error $Pe(u_i)=Pe(w^{(i)})$, assuming that ${\hat{u}}_1^{i-1}=u_1^{i-1}$ (${\hat{u}}_1^{i-1}:u1,u2,...,u_{i-1}$)
Lemma: Pe(the polar code associated with A and decoded with SC) $\le {\sum }_{i\in A}Pe(u_i)$
$Pe(u_i)$: probability of error of individual bit-channel

PROOF:
by union bound on the error events ${\hat{u}}_i\ne u_i$ for the first(smallest) i, going back to the construction of polar code, there are two criteria:

1. For a fixed rate: sort the bit-channels and pick the best $k-nR$ , R:given rate. Finding the rate, $n$ block length, $n=2^m$ rate $R$, dimension $k=nR$. Polarization transform of length $n$, split into $n$ bit-channels $w^{(1)}{w}^{(2)}...w^{(n)}$. Sort them (according to capacity or probability of erasure) pick the best $k$ of them, let $A=$ set of indices of the selected/good ones.
2. For a given bound on $Pe$. Pe(polar code associated with A under SC)$\le {\sum }_{i\in A}Pe(u_i)$, $u_i$: for bit-channel $w^{(i)}$.
   Sort the bit-channels from best to worse $u_{\pi (1)}{u}_{\pi (2)}...u_{\pi (n)}$ - sorting permutation according to $Re(u_i)$
   $u_n$ is always the best $\pi (1)=n$
   $u_1$ is always the worst $\pi (n)=1$
   $u_{\pi (n)}\to$then accumulate as many $u_{\pi (i)}$'s as possible (starting from $\pi (1)$ till the sum ${\sum }_{i=1}^{k}Pe(u_{\pi (i)})$ reaches the bound on $Pe$)

Example:
for n=8 k=4 BEC($\frac{1}{2}$)

standard : $Pe<\frac{1}{3}$
$\sum Pe=\frac{1}{256}+\frac{31}{256}+\frac{49}{256}=\frac{81}{256}<\frac{1}{3}$ good
but if $+Pe(u_{\pi (4)})$,$\sum Pe$ will greater than $\frac{1}{3}$, $\sim k=3$, set of good bit-channels, A = { 8 , 7 , 6 } A=\{8,7,6\} A={8,7,6}

（未完，接：Advances in Wireless Communication 课堂笔记（中））