Код хемминга онлайн

Программа, демонстрирующая самокорректирующие возможности

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

В настоящей программе, демонстрирующей кодирование и декодирование любого файла (или любого текста введенного в верхнее окно) пользователь может:

Рис.1 Программа, демонстрирующая самокорректирующие возможности

  1. Провести первичное кодирование, при этом
  • Первичный текст делится на пакеты по 8 байт (или 64 бита)
  • Вычисляются 7 контрольных бит и бит четности, формируя, таким образом, дополнительный контрольный байт, который и размещается после 8 исходных байт.
  • Во второе окно выводятся 72-битные пакеты кодограммы

  • Далее, можно инвертировать любое количество бит во втором окне и обязательно щелкнуть «Сохранить изменения», чтобы ошибочные биты отличительно покраснели Если не хотите загонять алгоритм Хемминга в пятый угол, то меняйте не более 2 бит в одном пакете
  • Далее можно щелкать «Проверить и исправить». Результат работы (проверки и самокоррекции) увидите в третьем окне
  • Кнопка «Декодировать», уберет не нужные больше контрольные биты в четверном окне (пакеты снова станут 64-битовыми), а в пятом предоставит исходный текст в символьном виде, причем, если ошибки не поддались коррекции, то текст будет искаженным (его отдельные символы)
  • В данном проекте используется тип wchar_t, т.е. битовые значения так называемых «широких символов» хранится в двух байтах, и, следовательно, в каждый пакет попадают по четыре символа

    Рис.2 Результат исправления умышленно внесенных ошибок

    Матрица для схемы (64, 7)

    Весь код достаточно длинен и сложен, поэтому здесь приведу только основные константы и матрицу:

    const char m=64; //бит в исходном пакете
    const char k=7; //контрольных бит
    const char n=m+k+1; //бит в закодированном пакете (72)
    unsigned char lenc; //9 байт в закодированном пакете переменная модуля
    unsigned char matr={
    //количество единиц в строке матрицы — нечетное
    // (т.к. одна в разряде)
    0,0,0,0,0,1,1, 1, // 7 — 1
    0,0,0,0,1,0,1, 1, // 11 — 2
    0,0,0,0,1,1,0, 1, // 13 — 3
    0,0,0,0,1,1,1, 0, // 14 — 4
    0,0,0,1,0,0,1, 1, // 19 — 5
    0,0,0,1,0,1,0, 1, // 21 — 6
    0,0,0,1,0,1,1, 0, // 22 — 7
    0,0,0,1,1,0,0, 1, // 25 — 8
    0,0,0,1,1,0,1, 0, // 26 — 9
    0,0,0,1,1,1,0, 0, // 28 — 10
    0,0,0,1,1,1,1, 1, // 31 — 11
    0,0,1,0,0,0,1, 1, // 35 — 12
    0,0,1,0,0,1,0, 1, // 37 — 13
    0,0,1,0,0,1,1, 0, // 38 — 14
    0,0,1,0,1,0,0, 1, // 41 — 15
    0,0,1,0,1,0,1, 0, // 42 — 16
    0,0,1,0,1,1,0, 0, // 44 — 17
    0,0,1,0,1,1,1, 1, // 47 — 18
    0,0,1,1,0,0,0, 1, // 49 — 19
    0,0,1,1,0,0,1, 0, // 50 — 20
    0,0,1,1,0,1,0, 0, // 52 — 21
    0,0,1,1,0,1,1, 1, // 55 — 22
    0,0,1,1,1,0,0, 0, // 56 — 23
    0,0,1,1,1,0,1, 1, // 59 — 24
    0,0,1,1,1,1,0, 1, // 61 — 25
    0,0,1,1,1,1,1, 0, // 62 — 26
    0,1,0,0,0,0,1, 1, // 67 — 27
    0,1,0,0,0,1,0, 1, // 69 — 28
    0,1,0,0,0,1,1, 0, // 70 — 29
    0,1,0,0,1,0,0, 1, // 73 — 30
    0,1,0,0,1,0,1, 0, // 74 — 31
    0,1,0,0,1,1,0, 0, // 76 — 32
    0,1,0,0,1,1,1, 1, // 79 — 33
    0,1,0,1,0,0,0, 1, // 81 — 34
    0,1,0,1,0,0,1, 0, // 82 — 35
    0,1,0,1,0,1,0, 0, // 84 — 36
    0,1,0,1,0,1,1, 1, // 87 — 37
    0,1,0,1,1,0,0, 0, // 88 — 38
    0,1,0,1,1,0,1, 1, // 91 — 39
    0,1,0,1,1,1,0, 1, // 93 — 40
    0,1,0,1,1,1,1, 0, // 94 — 41
    0,1,1,0,0,0,0, 1, // 97 — 42
    0,1,1,0,0,0,1, 0, // 98 — 43
    0,1,1,0,0,1,0, 0, // 100 — 44
    0,1,1,0,0,1,1, 1, // 103 — 45
    0,1,1,0,1,0,0, 0, // 104 — 46
    0,1,1,0,1,0,1, 1, // 107 — 47
    0,1,1,0,1,1,0, 1, // 109 — 48
    0,1,1,0,1,1,1, 0, // 110 — 49
    0,1,1,1,0,0,0, 0, // 112 — 50
    0,1,1,1,0,0,1, 1, // 115 — 51
    0,1,1,1,0,1,0, 1, // 117 — 52
    0,1,1,1,0,1,1, 0, // 118 — 53
    0,1,1,1,1,0,0, 1, // 121 — 54
    0,1,1,1,1,0,1, 0, // 122 — 55
    0,1,1,1,1,1,0, 0, // 124 — 56
    0,1,1,1,1,1,1, 1, // 127 — 57
    1,0,0,0,0,0,1, 1, // 131 — 58
    1,0,0,0,0,1,0, 1, // 133 — 59
    1,0,0,0,0,1,1, 0, // 134 — 60
    1,0,0,0,1,0,0, 1, // 137 — 61
    1,0,0,0,1,0,1, 0, // 138 — 62
    1,0,0,0,1,1,0, 0, // 140 — 63
    1,0,0,0,1,1,1, 1, // 143 — 64
    1,0,0,0,0,0,0, 0,
    0,1,0,0,0,0,0, 0,
    0,0,1,0,0,0,0, 0,
    0,0,0,1,0,0,0, 0,
    0,0,0,0,1,0,0, 0,
    0,0,0,0,0,1,0, 0,
    0,0,0,0,0,0,1, 0,
    0,0,0,0,0,0,0, 1
    };

    Каждая строка этой матрицы соответствует порядковому номеру бита в пакете Поэтому для кодирования достаточно перемножить вектор-строку исходных бит (длиною 64) на 64 строки данной матрицы На выходе получится вектор-строка из 8 бит (это и есть контрольный байт), который следует прибавить в конец т.е. девятым байтом и длина закодированного пакета станет 72 бита Конечно, есть некоторые тонкости, которые прописаны в коде и благодаря которым, алгоритм работает достаточно стабильно.

    При декодировании 72-битная строка перемножается на ту же матрицу и результатом будет являться байт синдромов, анализ битов которого и дает однозначный ответ о наличии ошибок и возможности коррекции

    Удачного Вам тестирования!

    Условия получения кода? Показать?

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

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

    Минимальные значения k при заданных значениях m, найденные в соответствии с этим неравенством, приведены в таблице.

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

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

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

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

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

    d ⩽ n ⋅ 2 k − 1 2 k − 1 {\displaystyle d\leqslant {\tfrac {n\cdot 2^{k-1}}{2^{k}-1}}}

    или

    r ≥ 2 ⋅ ( d − 1 ) − log 2 ⁡ d {\displaystyle r\geq 2\cdot (d-1)-\log _{2}d}

    при n ≥ 2 ⋅ d − 1 {\displaystyle n\geq 2\cdot d-1}

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

    2 k ≤ 2 n / ∑ i = 0 d − 1 2 C n i {\displaystyle 2^{k}\leq {2^{n}}/\sum _{i=0}^{\tfrac {d-1}{2}}C_{n}^{i}}

    где C n i {\displaystyle C_{n}^{i}} — число сочетаний из n элементов по i элементам. Отсюда можно получить выражение для оценки числа проверочных символов: : r ≥ l o g 2 ( ∑ i = 0 d − 1 2 C n i ) {\displaystyle r\geq log_{2}(\sum _{i=0}^{\tfrac {d-1}{2}}C_{n}^{i})}

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

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

    r ≥ l o g 2 ( ∑ i = 0 d − 2 C n − 1 i ) {\displaystyle r\geq log_{2}(\sum _{i=0}^{d-2}C_{n-1}^{i})}

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

    Код Хэмминга

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

    r 1 = i 1 ⊕ i 2 ⊕ . . . ⊕ i k . {\displaystyle r_{1}=i_{1}\oplus i_{2}\oplus …\oplus i_{k}.}

    знак ⊕ {\displaystyle \oplus } здесь означает сложение по модулю 2

    S = i 1 ⊕ i 2 ⊕ . . . ⊕ i n ⊕ r 1 {\displaystyle S=i_{1}\oplus i_{2}\oplus …\oplus i_{n}\oplus r_{1}}.

    S = 0 {\displaystyle S=0} — ошибки нет, S = 1 {\displaystyle S=1} однократная ошибка.

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

    Для каждого числа проверочных символов r = 3 , 4 , 5.. {\displaystyle r=3,4,5..} существует классический код Хэмминга с маркировкой ( n , k ) = ( 2 r − 1 , 2 r − 1 − r ) {\displaystyle (n,k)=(2^{r}-1,2^{r}-1-r)} то есть — ( 7 , 4 ) , ( 15 , 11 ) , ( 31 , 26 ) {\displaystyle (7,4),(15,11),(31,26)} . При иных значениях k получается так называемый усеченный код, например международный телеграфный код МТК-2, у которого k = 5 {\displaystyle k=5} . Для него необходим код Хэмминга ( 9 , 5 ) {\displaystyle (9,5)} , который является усеченным от классического ( 15 , 11 ) {\displaystyle (15,11)} .

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

    r 1 = i 1 ⊕ i 2 ⊕ i 3 {\displaystyle r_{1}=i_{1}\oplus i_{2}\oplus i_{3}}r 2 = i 2 ⊕ i 3 ⊕ i 4 {\displaystyle r_{2}=i_{2}\oplus i_{3}\oplus i_{4}}r 3 = i 1 ⊕ i 2 ⊕ i 4 {\displaystyle r_{3}=i_{1}\oplus i_{2}\oplus i_{4}}

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

    ( i 1 i 2 i 3 i 4 ) {\displaystyle {\begin{pmatrix}i_{1}&i_{2}&i_{3}&i_{4}&\\\end{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 ) {\displaystyle {\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}}}= ( i 1 i 2 i 3 i 4 r 1 r 2 r 3 ) {\displaystyle {\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 ′ ) {\displaystyle V=(i_{1}’,i_{2}’,i_{3}’,i_{4}’,r_{1}’,r_{2}’,r_{3}’)} где штрихом помечены символы, которые могут исказиться в результате помехи. В декодере в режиме исправления ошибок строится последовательность синдромов:

    S 1 = r 1 ⊕ i 1 ⊕ i 2 ⊕ i 3 {\displaystyle S_{1}=r_{1}\oplus i_{1}\oplus i_{2}\oplus i_{3}}S 2 = r 2 ⊕ i 2 ⊕ i 3 ⊕ i 4 {\displaystyle S_{2}=r_{2}\oplus i_{2}\oplus i_{3}\oplus i_{4}}S 3 = r 3 ⊕ i 1 ⊕ i 2 ⊕ i 4 {\displaystyle S_{3}=r_{3}\oplus i_{1}\oplus i_{2}\oplus i_{4}}

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

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

    ( i 1 i 2 i 3 i 4 r 1 r 2 r 3 ) {\displaystyle {\begin{pmatrix}i_{1}&i_{2}&i_{3}&i_{4}&r_{1}&r_{2}&r_{3}\\\end{pmatrix}}}( 1 0 1 1 1 1 1 1 0 0 1 1 1 0 0 0 1 0 0 0 1 ) {\displaystyle {\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}}}= ( S 1 S 2 S 3 ) {\displaystyle {\begin{pmatrix}S_{1}&S_{2}&S_{3}\\\end{pmatrix}}}

    Кодовые слова ( 7 , 4 ) {\displaystyle (7,4)} кода Хэмминга

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

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

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

    Предположим, что нужно сгенерировать код Хэмминга для некоторого информационного кодового слова. В качестве примера возьмём 15-битовое кодовое слово x1…x15, хотя алгоритм пригоден для кодовых слов любой длины. В приведённой ниже таблице в первой строке даны номера позиций в кодовом слове, во второй — условное обозначение битов, в третьей — значения битов.

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15
    1 0 0 1 0 0 1 0 1 1 1 0 0 0 1

    Вставим в информационное слово контрольные биты r0…r4 таким образом, чтобы номера их позиций представляли собой целые степени двойки: 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
    r0 r1 x1 r2 x2 x3 x4 r3 x5 x6 x7 x8 x9 x10 x11 r4 x12 x13 x14 x15
    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.

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

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

    Например, для строки r0:

    r0 = (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.

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

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

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

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

    Литература

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

    Субтитры

    Алиса и Боб нашли замечательный трюк. Они обмениваются сообщениями через щипки провода, которые могут быть жёсткими или мягкими, для передачи нулей и единиц. Однако из-за порывов ветра, появляются искажённые нули и единицы во время передачи, и это приводит к ошибкам. Хотя они нашли способ связи без ошибок. Даже в присутствии помех. Как они могли бы сделать это? В 1940-х годах Ричард Хэмминг столкнулся с похожей задачей, пока работал в Лабораториях Белла. «В Телефонных Лабораториях Белла мы проводим около 10% экспериментов на компьютере, а около 90% — в лаборатории. Хотя мы надеемся, что со временем мы будем проводить 90% на компьютере, а 10% в лаборатории. По скорости, стоимости и необходимым усилиям подход с использованием компьютера выгоднее лабораторного подхода». В то время компьютеры использовали информацию, хранящуюся на перфокартах. Единицы и нули были представлены наличием и отсутствием отверстия соответственно. Такая система была предрасположена к ошибкам, так как было обычным делом, когда карты загибались или отверстия делались в изначально неверных местах. Так что отверстия могли быть пропущены или наоборот быть проставлены в местах, где их не должно было быть, что приводило к перевёрнутым битам. Эти ошибки могли приводить к остановке всей системы, пока место ошибки не было найдено и исправлено вручную. Итак, Хэмминг взял дело в свои руки и начал разрабатывать метод, который помог бы автоматически находить и исправлять отдельные ошибочные биты без прерывания вычислений. Его решение исходило из интуитивной идеи повторения. Это то, что мы все делаем, когда сталкиваемся с интерференцией или возможностью того, что часть нашего сообщения будет искажено. Его коды, исправляющие ошибки, строятся на простом понятии бита чётности. Бит чётности — это отдельный бит, который добавляется в конец сообщения и показывает, что количество единиц в сообщении чётно или нет. Если случается одна ошибка, то получатель сможет узнать об этом, так как бит чётности не будет больше подходить. Однако, для нахождения и исправления одиночных ошибок Хэммингу нужно было добавить больше битов чётности для определения точного места ошибки. Что приводит нас к его (7, 4) коду, который добавляет 3 контрольных бита на каждый блок из 4 битов информации: Начнём с 3 битов чётности, которые можно представить кругами. Там, где эти круги пересекаются, получаются 4 области. 4 бита информации помещаются в эти области в определённом порядке. Теперь для вычисления битов чётности мы берём каждый круг по порядку, он содержит 3 из 4-х информационных битов. Бит чётности определяется как и раньше. Складываем информационные биты, и если получается 0 или 2, то бит чётности равен 0, то есть он чётный. Если же получается 1 или 3, то бит чётности равен 1, то есть он нечётный. Сделав это для всех кругов получаем 3 бита чётности, соответствующих 4 информационным битам. Они помещаются в обычной последовательности так. Понятно, что эта система может автоматически исправлять одиночные ошибки по простому правилу. Если случилась одиночная ошибка, 2 или более битов чётности будут неправильными. То место, где они пересекаются, и есть место ошибки. Этот бит на пересечении нужно просто автоматически обратить, чтобы все биты чётности стали снова правильными. Вот и весь фокус Алисы и Боба. Дополнительные биты чётности называются избыточными разрядами, потому что они не несут никакой новой информации. Все коды, исправляющие ошибки, работают таким образом. Они все немного увеличивают размер исходных сообщений взамен на автоматическое исправление ошибок. Мы используем коды, исправляющие ошибки, также и для хранения. Например на физических компакт-дисках информация закодирована с помощью специального кода, чтобы исправлять последовательности ошибок, вызванных царапинами или пылью, которые повреждают длинные последовательности нулей и единиц, хранящихся на поверхности. Именно поэтому можно поцарапать диск, и чаще всего он будет продолжать проигрываться нормально. Клод Шеннон использовал эту идею избыточности для переопределения ёмкости канала связи. По мере увеличения помех в канале, нам приходится увеличивать избыточность для поддержания безошибочной связи. Но это неминуемо снижает реальное количество информации, которое мы можем пересылать за единицу времени.

    >
    Код Хэмминга. Пример работы алгоритма

    Вступление.

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

    Как это работает.

    Для того, чтобы понять работу данного алгоритма, рассмотрим пример.

    Подготовка

    Допустим, у нас есть сообщение «habr», которое необходимо передать без ошибок. Для этого сначала нужно наше сообщение закодировать при помощи Кода Хэмминга. Нам необходимо представить его в бинарном виде.

    На этом этапе стоит определиться с, так называемой, длиной информационного слова, то есть длиной строки из нулей и единиц, которые мы будем кодировать. Допустим, у нас длина слова будет равна 16. Таким образом, нам необходимо разделить наше исходное сообщение («habr») на блоки по 16 бит, которые мы будем потом кодировать отдельно друг от друга. Так как один символ занимает в памяти 8 бит, то в одно кодируемое слово помещается ровно два ASCII символа. Итак, мы получили две бинарные строки по 16 бит:
    и
    После этого процесс кодирования распараллеливается, и две части сообщения («ha» и «br») кодируются независимо друг от друга. Рассмотрим, как это делается на примере первой части.
    Прежде всего, необходимо вставить контрольные биты. Они вставляются в строго определённых местах — это позиции с номерами, равными степеням двойки. В нашем случае (при длине информационного слова в 16 бит) это будут позиции 1, 2, 4, 8, 16. Соответственно, у нас получилось 5 контрольных бит (выделены красным цветом):
    Было:

    Стало:

    Таким образом, длина всего сообщения увеличилась на 5 бит. До вычисления самих контрольных бит, мы присвоили им значение «0».

    Вычисление контрольных бит.

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

    Здесь знаком «X» обозначены те биты, которые контролирует контрольный бит, номер которого справа. То есть, к примеру, бит номер 12 контролируется битами с номерами 4 и 8. Ясно, что чтобы узнать какими битами контролируется бит с номером N надо просто разложить N по степеням двойки.
    Но как же вычислить значение каждого контрольного бита? Делается это очень просто: берём каждый контрольный бит и смотрим сколько среди контролируемых им битов единиц, получаем некоторое целое число и, если оно чётное, то ставим ноль, в противном случае ставим единицу. Вот и всё! Можно конечно и наоборот, если число чётное, то ставим единицу, в противном случае, ставим 0. Главное, чтобы в «кодирующей» и «декодирующей» частях алгоритм был одинаков. (Мы будем применять первый вариант).
    Высчитав контрольные биты для нашего информационного слова получаем следующее:

    и для второй части:

    Вот и всё! Первая часть алгоритма завершена.

    Декодирование и исправление ошибок.

    Теперь, допустим, мы получили закодированное первой частью алгоритма сообщение, но оно пришло к нас с ошибкой. К примеру мы получили такое (11-ый бит передался неправильно):

    Вся вторая часть алгоритма заключается в том, что необходимо заново вычислить все контрольные биты (так же как и в первой части) и сравнить их с контрольными битами, которые мы получили. Так, посчитав контрольные биты с неправильным 11-ым битом мы получим такую картину:

    Как мы видим, контрольные биты под номерами: 1, 2, 8 не совпадают с такими же контрольными битами, которые мы получили. Теперь просто сложив номера позиций неправильных контрольных бит (1 + 2 + 8 = 11) мы получаем позицию ошибочного бита. Теперь просто инвертировав его и отбросив контрольные биты, мы получим исходное сообщение в первозданном виде! Абсолютно аналогично поступаем со второй частью сообщения.

    Заключение.

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

    Примечание.

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