在传输信息时，可能会产生随机的错误，影响信息的可靠性。由于产生的错误时随机不可控也不可避免的，因此就需要对传递的信息加工，使其能适应这一特性，所以在这里引入信道编码：线性分组码

假设现在又3位二进制信息需要发送，如果不加变动的发送，虽然说这样的编码效率最高，完全没有多余的信息被传输，但是相对的，一旦出错也无从得知，所以这样是不可取的。
那现在在发送端对这个3bit的信息组 $(c_1,c_2,c_3)$进行加工，令这3位按照一定的规则排列¹得到检校位如下，再将信息位和检校位共同发送
$\begin{cases} c_4=c_1+c_3 \\ c_5=c_1+c_2+c_3 \\ c_6=c_1+c_2 \\ c_7=c_2+c_3 \end{cases} \tag{1}$

那么在接受端只需要将信息位按照同样的规则排列，就可以检校这组信息在传输的过程中有没有出错了
很明显，在经过编码之后，有用信息的占比下降了，信息位在码字中的占比，也就是编码效率降到了 $\frac 37 \approx 0.4286$

在上面的例子中不难看出，我们在传输的过程中增加了冗余，也就是多发送了4位没有用的信息，换来在接受端可以检校，简而言之：提高传输的可靠性降低了传输的有效性
这一点也正是信道编码的一个本质，信道编码是为了提高传输的可靠性，但是可靠性与有效性不可兼得，只能倾向一点而不能二者兼顾

上面给出的例子就是线性分组码.编码后码长n=7，编码前码长k=3，添加检校位r=4.其最明显的特征就是检校位由信息位线性组合构成,根据这个套用一下线性代数的知识，将上面的方程组(1)变成矩阵的形式

$\begin{bmatrix} c_1 & c_2 & c_3 \end{bmatrix} \cdot \begin{bmatrix} 1&1&1&0\\0&1&1&1\\1&1&0&1 \end{bmatrix}= \begin{bmatrix} c_4&c_5&c_6&c_7 \end{bmatrix}$

加上信息位则有
$\begin{bmatrix} c_1 & c_2 & c_3 \end{bmatrix} \cdot \begin{bmatrix} 1&0&0&1&1&1&0\\0&1&0&0&1&1&1\\0&0&1&1&1&0&1 \end{bmatrix}= \begin{bmatrix} c_1 & c_2 & c_3&c_4&c_5&c_6&c_7 \end{bmatrix}$

在上式中，中间的系数矩阵就是线性分组码的生成矩阵G
$\begin{bmatrix} 1&0&0&1&1&1&0\\0&1&0&0&1&1&1\\0&0&1&1&1&0&1 \end{bmatrix}$

对于上述生成矩阵G，可以大致分为两部分
$\begin{bmatrix} I|P \end{bmatrix} \tag{2}$
这样生成的码字，左侧为信息位，也就是要传送的信息，右侧为检校位。
但不是所有线性分组码的生成矩阵都具有如此简洁的形式，我们将生成矩阵能划分为(2)的线性分组码称为系统码，而不具备这种形式的则称为非系统码。关于非系统码将会在循环码中出现，这里不作详细说明，仅说明一点：系统码和非系统码的关系
对矩阵仅作初等行变换或列变换，变换前后的矩阵是等价的，那么对于每一个非系统码的生成矩阵，便一定对应一个系统码的生成矩阵。也就是说，我们一定可以通过初等行变换或列变换将非系统码转换为系统码

在生成矩阵的描述下，我们又多了一种新的理解方式
将生成矩阵G写为行向量的形式
$\begin{bmatrix} g_1 \\ g_2 \\g_3 \end{bmatrix}$

那么不难看出我们所得到码字c实际上是行向量的线性组合
$c=c_1 g_1+c_2g_2+c_3g_3 \tag{3}$

所以生成矩阵中的每个行向量就是一个码字。那么我们所得到的码字也就是其中三个基本码字的线性组合，或者说，这三个码字作为基底描述了一个码字空间，就这一点我们得知如下特点：

1. 码字具有封闭性
   由于是定义在GF{2}上的运算，对于任意两码字 $c_i,c_j$,都可分解后相加
   $c_i+c_j=(c_{1i}+c_{1j})g_1+(c_{2i}+c_{2j})g_2+(c_{3i}+c_{3j})g_3$
   根据GF{2}上运算的封闭性,必定存在 $c_k$使得
   $\begin{cases} c_{1k}=c_{1i}+c_{1j} \\ c_{2k}=c_{2i}+c_{2j} \\ c_{3k}=c_{3i}+c_{3j} \end{cases}$
   进而 $c_k=c_i+c_j$
   所以码字具有封闭性

2. 线性分组码一定包含全零序列

3. 各行向量线性无关

现在再来看接受端的情况：
在经过信道之后，可能产生一个随机错误，同样可以用矩阵去描述，仍以上述(7,3)码为例，假设传输过程中产生的错误
$e=[0 \quad 1 \quad 0 \quad 0\quad 0 \quad0 \quad0 ] \tag{4}$

因此接受端接收到的是随机错误e和码字c的叠加
$r=e+c$

此时根据编码规则(1)在接受端的检校排列
$\begin{cases} r_1+r_3+r_4=0 \\ r_1+r_2+r_3+r_5=0 \\ r_1+r_2+r_6=0 \\ r_2+r_3+r_7=0 \end{cases} \tag{5}$
对应的检校矩阵 $H^T$如下：
$\begin{bmatrix} 1&1&1&0\\0&1&1&1\\1&1&0&1\\1&0&0&0\\0&1&0&0\\0&0&1&0\\0&0&0&1 \end{bmatrix}$

对于满足编码规则的码字c同样也满足检校规则，所以
$c \cdot H^T =0$

而随机错误不具备这一特点，就会出现一不为零的行向量，记为伴随式S
$e\cdot H^T =S$

综上，我们在接受端对接收码字的检校得到是随机错误e的伴随式S
$r\cdot H^T =S$

接下来着重探讨一下这个伴随式S，随即错误为(4)中单错误形式。可以看到
$e\cdot \begin{bmatrix} h_1&h_2&h_3&h_3&h_4&h_5&h_6&h_7\end{bmatrix}^T = h^T_2$
得到的伴随式S就是检校矩阵 $H^T$的行向量，而各行均不相同，因此可以根据得到的伴随式S进行纠错。
同样我们可以推广到t个错误的情况，此时的伴随式S变为多个 $H^T$行向量的线性组合，只要能保证2t个行向量之间线性无关，那么就可以纠正这t个错误，关于纠错能力将在另一篇文章中说明，这里不进一步深入。

结合关于伴随式S的说明，接收端的译码步骤如下：
首先得到该接收码字的伴随式S，再由伴随式S对应得知可能的错误形式 $\hat{e}$,最后消除错误 $c=r+\hat{e}$恢复码字

这里为什么说得到的是可能的错误？
因为在信道中发生的错误不可控的，一个码字可能发生多个错误变成另一个码字，但因为同时发生多个错误的概率要远远小于发生一个错误的概率，因此我们选择概率上可能最大的情况。虽然发生多个错误的概率非常小，但是也有可能发生，按照上述选择方案，就出现了传输过程中的误码。
此外如果发生错误超过纠错能力，在判决时也无法正确抉择，同样近似选择可能性最大的，这里不详细说明。

得到码字进行译码。现在系统码的优势就体现出来了，直接截取前3位就是传输信息组；如果是非系统码，则需要额外译码运算

最后附(7,3)的matlab仿真代码：
传输信息组(0 1 0)，由随机数生成单随机错误
列出全部错误图样对应的伴随式

for i=1:7
	error_sample=zeros(1,7);
	error_sample(i)=1;
	error_sample
	S=error_sample*H'
end

并将二进制序列转为10进制，按升序排列，接收码字得到其伴随式之后同样转为10进制，再二分查找，匹配到对应的错误图样

close all;
clear all;
clc

N=7;
k=3;
t=1;
%generate matrix
G=[1 0 0 1 1 1 0;0 1 0 0 1 1 1;0 0 1 1 1 0 1];
H=gen2par(G);
u=[0 1 0];
%decode tab
map=[7 6 5 2 4 3 1];
tab=[1 2 4 7 8 13 14];

%encode
c=u*G;
%make mistake in transprot
e=zeros(1,N);
for i=1:t
    pos=randi(N);
    e(pos)=mod(e(pos)+1,2);
end
%in receive
r=mod(c+e,2);
S=mod(r*H',2);% get S
%match S in tab
num=0;tem=1;
for i=4:-1:1    %bin to int
    num=num+S(i)*tem;
    tem=tem*2;
end
inf=0;sup=7;    %binary search
while(inf<sup-1)
    mid=inf+fix((sup-inf)/2);
    if(num>tab(mid))
        inf=mid;
    else
        sup=mid;
    end
end
%get error sample
CE=zeros(1,N);
CE(map(sup))=1;
%correct error
rec=mod(r+CE,2);
rec_u=rec(1,1:3);