Код Хэмминга

Двоичный код Хэмминга
Двоичный код Хэмминга
	; Код Хэмминга с
Назван в честь	Ричард Хэмминг
Тип	линейный блочный код
Длина блока
Длина сообщения
Доля
Расстояние	3
Размер алфавита	2
Обозначение
	Медиафайлы на Викискладе

Код Хэ́мминга — самоконтролирующийся и самокорректирующийся код. Построен применительно к двоичной системе счисления.

Позволяет исправлять одиночную ошибку (ошибка в одном бите слова) и находить двойную^[1].

Назван в честь американского математика Хэмминга Ричарда Уэсли, предложившего код.

История

В середине 1940-х годов в лаборатории Белла была создана счётная машина Bell Model V. Это была электромеханическая машина, использующая релейные блоки, скорость которых была очень низка: одна операция за несколько секунд. Данные вводились в машину с помощью перфокарт с ненадёжными устройствами чтения, поэтому в процессе чтения часто происходили ошибки. В рабочие дни использовались специальные коды, чтобы обнаруживать и исправлять найденные ошибки, при этом оператор узнавал об ошибке по свечению лампочек, исправлял и снова запускал машину. В выходные дни, когда не было операторов, при возникновении ошибки машина автоматически выходила из программы и запускала другую.

Хэмминг часто работал в выходные дни и всё больше раздражался, так как должен был перезагружать свою программу из-за ненадёжности считывателя перфокарт. На протяжении нескольких лет он искал эффективный алгоритм исправления ошибок. В 1950 году он опубликовал способ кодирования, который известен как код Хэмминга.

Систематические коды

Систематические коды образуют большую группу из блочных, разделимых кодов (в которых все символы слова можно разделить на проверочные и информационные). Особенностью систематических кодов является то, что проверочные символы образуются в результате линейных логических операций над информационными символами. Кроме того, любая разрешенная кодовая комбинация может быть получена в результате линейных операций над набором линейно независимых кодовых комбинаций.

Самоконтролирующиеся коды

Коды Хэмминга являются самоконтролирующимися кодами, то есть кодами, позволяющими автоматически обнаруживать ошибки при передаче данных. Для их построения достаточно приписать к каждому слову один добавочный (контрольный) двоичный разряд и выбрать цифру этого разряда так, чтобы общее количество единиц в изображении любого числа было, например, нечётным. Одиночная ошибка в каком-либо разряде передаваемого слова (в том числе, может быть, и в контрольном разряде) изменит чётность общего количества единиц. Счётчики по модулю 2, подсчитывающие количество единиц, которые содержатся среди двоичных цифр числа, дают сигнал о наличии ошибок. При этом невозможно узнать, в какой именно позиции слова произошла ошибка, и, следовательно, нет возможности исправить её. Остаются незамеченными также ошибки, возникающие одновременно в двух, четырёх, и т. д. — в чётном количестве разрядов. Предполагается, что двойные, а тем более многократные ошибки маловероятны.

Самокорректирующиеся коды

Коды, в которых возможно автоматическое исправление ошибок, называются самокорректирующимися. Для построения самокорректирующегося кода, рассчитанного на исправление одиночных ошибок, одного контрольного разряда недостаточно. Как видно из дальнейшего, количество контрольных разрядов $k$ должно быть выбрано так, чтобы удовлетворялось неравенство $2^{k}\geq k+m+1$ или $k\geq \log _{2}(k+m+1)$ , где $m$ — количество информационных двоичных разрядов кодового слова. Минимальные значения k при заданных значениях m, найденные в соответствии с этим неравенством, приведены в таблице.


Диапазон m	k_min
1	2
2-4	3
5-11	4
12-26	5
27-57	6

Наибольший интерес представляют двоичные блочные корректирующие коды. При использовании таких кодов информация передаётся в виде блоков одинаковой длины, и каждый блок кодируется и декодируется независимо от другого. Почти во всех блочных кодах символы можно разделить на информационные и проверочные или контрольные. Таким образом, все слова разделяются на разрешённые (для которых соотношение информационных и проверочных символов возможно) и запрещённые.

Основные характеристики самокорректирующихся кодов:

Число разрешённых и запрещённых комбинаций. Если $n$ — число символов в блоке, $r$ — число проверочных символов в блоке, $k$ — число информационных символов, то $2^{n}$ — число возможных кодовых комбинаций, $2^{k}$ — число разрешённых кодовых комбинаций, $2^{n}-2^{k}$ — число запрещённых комбинаций.
Избыточность кода. Величину ${\tfrac {r}{n}}$ называют избыточностью корректирующего кода.
Минимальное кодовое расстояние. Минимальным кодовым расстоянием $d$ называется минимальное число искажённых символов, необходимое для перехода одной разрешённой комбинации в другую.
Число обнаруживаемых и исправляемых ошибок. Если $g$ — количество ошибок, которое код способен исправить, то необходимо и достаточно, чтобы $d\geq 2g+1$
Корректирующие возможности кодов.

Граница Плоткина даёт верхнюю границу кодового расстояния:

d\leqslant {\tfrac {n\cdot 2^{k-1}}{2^{k}-1}},

или:

r\geq 2\cdot (d-1)-\log _{2}d

при

n\geq 2\cdot d-1.

Граница Хэмминга устанавливает максимально возможное число разрешённых кодовых комбинаций:

2^{k}\leq {2^{n}}/\sum _{i=0}^{\tfrac {d-1}{2}}C_{n}^{i},

где

C_{n}^{i}

— число сочетаний из

n

элементов по

i

элементам. Отсюда можно получить выражение для оценки числа проверочных символов:

r\geq \log _{2}\left(\sum _{i=0}^{(d-1)/2}C_{n}^{i}\right).

Для значений $(d/n)\leq 0{,}3$ разница между границей Хэмминга и границей Плоткина невелика.

Граница Варшамова — Гилберта для больших n определяет нижнюю границу числа проверочных символов:

r\geq \log _{2}\left(\sum _{i=0}^{d-2}C_{n-1}^{i}\right).

Все вышеперечисленные оценки дают представление о верхней границе $d$ при фиксированных $n$ и $k$ или оценку снизу числа проверочных символов.

Код Хэмминга

Построение кодов Хэмминга основано на принципе проверки на чётность числа единичных символов: к последовательности добавляется такой элемент, чтобы число единичных символов в получившейся последовательности было чётным:

r_{1}=i_{1}\oplus i_{2}\oplus ...\oplus i_{k}.

Знак $\oplus$ здесь означает сложение по модулю 2:

S=i_{1}\oplus i_{2}\oplus ...\oplus i_{n}\oplus r_{1}.

Если $S=0$ — то ошибки нет, если $S=1$ — то однократная ошибка.

Такой код называется $(k+1,\ k)$ или $(n,\ n-1)$ . Первое число — количество элементов последовательности, второе — количество информационных символов.

Для каждого числа проверочных символов $r=3,\ 4,\ 5\ ...$ существует классический код Хэмминга с маркировкой:

(n,k)=(2^{r}-1,2^{r}-1-r),

то есть —

(7,4),(15,11),(31,26)

.

При иных значениях $k$ получается так называемый усечённый код — например, телеграфный код Бодо, у которого $k=5$ . Для него необходим код Хэмминга $(9,\ 5),$ который является усечённым от классического $(15,\ 11).$

Для примера рассмотрим классический код Хэмминга $(7,\ 4)$ . Сгруппируем проверочные символы следующим образом:

r_{1}=i_{1}\oplus i_{2}\oplus i_{3},

r_{2}=i_{2}\oplus i_{3}\oplus i_{4},

r_{3}=i_{1}\oplus i_{2}\oplus i_{4}.

Получение кодового слова выглядит следующим образом:

{\begin{pmatrix}i_{1}&i_{2}&i_{3}&i_{4}&\\\end{pmatrix}}

{\begin{pmatrix}1&0&0&0&1&0&1\\0&1&0&0&1&1&1\\0&0&1&0&1&1&0\\0&0&0&1&0&1&1\\\end{pmatrix}}

=

{\begin{pmatrix}i_{1}&i_{2}&i_{3}&i_{4}&r_{1}&r_{2}&r_{3}\\\end{pmatrix}}

.

На вход декодера поступает кодовое слово $V=(i_{1}',\ i_{2}',\ i_{3}',\ i_{4}',\ r_{1}',\ r_{2}',\ r_{3}')$ , где штрихом помечены символы, которые могут исказиться в результате действия помехи. В декодере в режиме исправления ошибок строится последовательность синдромов:

S_{1}=r_{1}\oplus i_{1}\oplus i_{2}\oplus i_{3},

S_{2}=r_{2}\oplus i_{2}\oplus i_{3}\oplus i_{4},

S_{3}=r_{3}\oplus i_{1}\oplus i_{2}\oplus i_{4}.

$S=(S_{1},\ S_{2},\ S_{3})$ называется синдромом последовательности.

Получение синдрома выглядит следующим образом:

{\begin{pmatrix}i_{1}&i_{2}&i_{3}&i_{4}&r_{1}&r_{2}&r_{3}\\\end{pmatrix}}

{\begin{pmatrix}1&0&1\\1&1&1\\1&1&0\\0&1&1\\1&0&0\\0&1&0\\0&0&1\\\end{pmatrix}}

=

{\begin{pmatrix}S_{1}&S_{2}&S_{3}\\\end{pmatrix}}

.

$i_{1}$	$i_{2}$	$i_{3}$	$i_{4}$	$r_{1}$	$r_{2}$	$r_{3}$	$i_{1}$	$i_{2}$	$i_{3}$	$i_{4}$	$r_{1}$	$r_{2}$	$r_{3}$
0	0	0	0	0	0	0	1	0	0	0	1	0	1
0	0	0	1	0	1	1	1	0	0	1	1	1	0
0	0	1	0	1	1	0	1	0	1	0	0	1	1
0	0	1	1	1	0	1	1	0	1	1	0	0	0
0	1	0	0	1	1	1	1	1	0	0	0	1	0
0	1	0	1	1	0	0	1	1	0	1	0	0	1
0	1	1	0	0	0	1	1	1	1	0	1	0	0
0	1	1	1	0	1	0	1	1	1	1	1	1	1

Кодовые слова $(7,\ 4)$ кода Хэмминга приведены в таблице.

Синдром $(0,0,0)$ указывает на то, что в последовательности нет искажений. Каждому ненулевому синдрому соответствует определённая конфигурация ошибок, которая исправляется на этапе декодирования.

Синдром	001	010	011	100	101	110	111
Конфигурация ошибок	0000001	0000010	0001000	0000100	1000000	0010000	0100000
Ошибка в символе	$r_{3}$	$r_{2}$	$i_{4}$	$r_{1}$	$i_{1}$	$i_{3}$	$i_{2}$

Для кода $(7,4)$ в таблице справа указаны ненулевые синдромы и соответствующие им конфигурации ошибок (для вида: $i_{1}$ $i_{2}$ $i_{3}$ $i_{4}$ $r_{1}$ $r_{2}$ $r_{3}$ ).

Алгоритм кодирования

Предположим, что нужно сгенерировать код Хэмминга для некоторого информационного кодового слова. В качестве примера возьмём 15-битовое кодовое слово $x_{1}\dots \ x_{15},$ хотя алгоритм пригоден для кодовых слов любой длины. В приведённой ниже таблице в первой строке даны номера позиций в кодовом слове, во второй — условное обозначение битов, в третьей — значения битов.

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
x₁	x₂	x₃	x₄	x₅	x₆	x₇	x₈	x₉	x₁₀	x₁₁	x₁₂	x₁₃	x₁₄	x₁₅
1	0	0	1	0	0	1	0	1	1	1	0	0	0	1

Вставим в информационное слово контрольные биты $r_{0}\dots \ r_{4}$ таким образом, чтобы номера их позиций представляли собой целые степени двойки: 1, 2, 4, 8, 16… Получим 20-разрядное слово с 15 информационными и 5 контрольными битами. Первоначально контрольные биты устанавливаем равными нулю. На рисунке контрольные биты выделены розовым цветом.

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20
r₀	r₁	x₁	r₂	x₂	x₃	x₄	r₃	x₅	x₆	x₇	x₈	x₉	x₁₀	x₁₁	r₄	x₁₂	x₁₃	x₁₄	x₁₅
0	0	1	0	0	0	1	0	0	0	1	0	1	1	1	0	0	0	0	1

В общем случае количество контрольных бит в кодовом слове равно двоичному логарифму числа, на единицу большего, чем количество бит кодового слова (включая контрольные биты); логарифм округляется в большую сторону. Например, информационное слово длиной 1 бит требует двух контрольных разрядов, 2-, 3- или 4-битовое информационное слово — трёх, 5…11-битовое — четырёх, 12…26-битовое — пяти и т. д.

Добавим к таблице 5 строк (по количеству контрольных битов), в которые поместим матрицу преобразования. Каждая строка будет соответствовать одному контрольному биту (нулевой контрольный бит — верхняя строка, четвёртый — нижняя), каждый столбец — одному биту кодируемого слова. В каждом столбце матрицы преобразования поместим двоичный номер этого столбца, причём порядок следования битов будет обратный — младший бит расположим в верхней строке, старший — в нижней. Например, в третьем столбце матрицы будут стоять числа 11000, что соответствует двоичной записи числа три: 00011.

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20
r₀	r₁	x₁	r₂	x₂	x₃	x₄	r₃	x₅	x₆	x₇	x₈	x₉	x₁₀	x₁₁	r₄	x₁₂	x₁₃	x₁₄	x₁₅
0	0	1	0	0	0	1	0	0	0	1	0	1	1	1	0	0	0	0	1
1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	r₀
0	1	1	0	0	1	1	0	0	1	1	0	0	1	1	0	0	1	1	0	r₁
0	0	0	1	1	1	1	0	0	0	0	1	1	1	1	0	0	0	0	1	r₂
0	0	0	0	0	0	0	1	1	1	1	1	1	1	1	0	0	0	0	0	r₃
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1	1	r₄

В правой части таблицы оставили пустым один столбец, в который поместим результаты вычислений контрольных битов. Вычисление контрольных битов производим следующим образом: берём одну из строк матрицы преобразования (например, $r_{0}$ ) и находим её скалярное произведение с кодовым словом, то есть перемножаем соответствующие биты обеих строк и находим сумму произведений. Если сумма получилась больше единицы, находим остаток от его деления на 2. Иными словами, мы подсчитываем, сколько раз в кодовом слове и соответствующей строке матрицы в одинаковых позициях стоят единицы, и берём это число по модулю 2.

Если описывать этот процесс в терминах матричной алгебры, то операция представляет собой перемножение матрицы преобразования на матрицу-столбец кодового слова, в результате чего получается матрица-столбец контрольных разрядов, которые нужно взять по модулю 2.

Например, для строки $r_{0}$ :

r_{0}

= (1·0+0·0+1·1+0·0+1·0+0·0+1·1+0·0+1·0+0·0+1·1+0·0+1·1+0·1+1·1+0·0+1·0+0·0+1·0+0·1) mod 2 = 5 mod 2 = 1.

Полученные контрольные биты вставляем в кодовое слово вместо стоявших там ранее нулей. По аналогии находим проверочные биты в остальных строках. Кодирование по Хэммингу завершено. Полученное кодовое слово — 11110010001011110001.

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20
r₀	r₁	x₁	r₂	x₂	x₃	x₄	r₃	x₅	x₆	x₇	x₈	x₉	x₁₀	x₁₁	r₄	x₁₂	x₁₃	x₁₄	x₁₅
1	1	1	1	0	0	1	0	0	0	1	0	1	1	1	1	0	0	0	1
1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	r₀	1
0	1	1	0	0	1	1	0	0	1	1	0	0	1	1	0	0	1	1	0	r₁	1
0	0	0	1	1	1	1	0	0	0	0	1	1	1	1	0	0	0	0	1	r₂	1
0	0	0	0	0	0	0	1	1	1	1	1	1	1	1	0	0	0	0	0	r₃	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1	1	r₄	1

Алгоритм декодирования

Алгоритм декодирования по Хэммингу абсолютно идентичен алгоритму кодирования. Матрица преобразования соответствующей размерности умножается на матрицу-столбец кодового слова, и каждый элемент полученной матрицы-столбца берётся по модулю 2. Полученная матрица-столбец получила название «матрица синдромов». Легко проверить, что кодовое слово, сформированное в соответствии с алгоритмом, описанным в предыдущем разделе, всегда даёт нулевую матрицу синдромов.

Матрица синдромов становится ненулевой, если в результате ошибки (например, при передаче слова по линии связи с шумами) один из битов исходного слова изменил своё значение. Предположим для примера, что в кодовом слове, полученном в предыдущем разделе, шестой бит изменил своё значение с нуля на единицу (на рисунке обозначено красным цветом). Тогда получим следующую матрицу синдромов.

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20
r₀	r₁	x₁	r₂	x₂	x₃	x₄	r₃	x₅	x₆	x₇	x₈	x₉	x₁₀	x₁₁	r₄	x₁₂	x₁₃	x₁₄	x₁₅
1	1	1	1	0	1	1	0	0	0	1	0	1	1	1	1	0	0	0	1
1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	1	0	s₀	0
0	1	1	0	0	1	1	0	0	1	1	0	0	1	1	0	0	1	1	0	s₁	1
0	0	0	1	1	1	1	0	0	0	0	1	1	1	1	0	0	0	0	1	s₂	1
0	0	0	0	0	0	0	1	1	1	1	1	1	1	1	0	0	0	0	0	s₃	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1	1	s₄	0

Заметим, что при однократной ошибке матрица синдромов всегда представляет собой двоичную запись (младший разряд в верхней строке) номера позиции, в которой произошла ошибка. В приведённом примере матрица синдромов (01100) соответствует двоичному числу 00110 или десятичному 6, откуда следует, что ошибка произошла в шестом бите.

Применение

Код Хэмминга используется:

в некоторых прикладных программах в области хранения данных;
при построении дисковых массивов RAID 2;
в памяти типа ECC и позволяет «на лету» исправлять однократные и обнаруживать двукратные ошибки.

См. также

Примечания

↑ Коды Хемминга — "Все о Hi-Tech" (неопр.). all-ht.ru. Дата обращения: 20 января 2016. Архивировано 15 января 2016 года.

Литература

Питерсон У., Уэлдон Э. Коды, исправляющие ошибки: Пер. с англ. М.: Мир, 1976, 594 c.
Пенин П. Е., Филиппов М.Р. Радиотехнические системы передачи информации. М.: Радио и Связь, 1984, 256 с.
Блейхут Р. Теория и практика кодов, контролирующих ошибки. Пер. с англ. М.: Мир, 1986, 576 с.

[1] Коды Хемминга — "Все о Hi-Tech" (неопр.). all-ht.ru. Дата обращения: 20 января 2016. Архивировано 15 января 2016 года.

[1]

Двоичный код Хэмминга
Код Хэмминга $(7,4)$ с $r=3$
Назван в честь	Ричард Хэмминг
Тип	линейный блочный код
Длина блока	$2^{r}-1$
Длина сообщения	$2^{r}-r-1$
Доля	$1-{\frac {2}{2^{r}-1}}$
Расстояние	3
Размер алфавита	2
Обозначение	$[2^{r}-1,2^{r}-r-1,3]_{2}$
Медиафайлы на Викискладе