Код Хэмминга - исправление ошибок исправляет биты сообщения вместо битов управления

Question

Здравствуйте, я не могу определить ошибку в моем коде, реализующем код Хэмминга. По сути, он делает следующее: получает сообщение (скажем, ASCII a: 01100001), умножает его на матрицу H, таким образом генерируя контрольные биты (биты четности) для этого сообщения. Мы делаем это, чтобы гарантировать, что если некоторые биты (в моем случае максимум 2 бита) будут переданы неправильно, он все равно сможет успешно декодировать. Моя матрица H равна 8x16. Таким образом, закодированное сообщение выглядит примерно так: 0110000110011110 (биты 0-7 — биты сообщения, 8-15 — управляющие биты)

...

Достаточно теории, мой код не может декодировать сообщения, если у меня есть 2 ошибки в управляющих битах. Если в битах сообщения есть 2 ошибки, оно успешно декодируется. Если где-то есть 1 ошибка, он также успешно декодируется. Когда я меняю два бита, скажем, в индексах 14 и 15, он обнаруживает ошибку в индексах 6 и 7. Я думаю, что моя ошибка где-то в этой функции:

       internal static void CorrectChar(List<int> message, List<int> errorVector, int[,] matrix_H)
    {
        if (errorVector.Count != ROWS)
        {
            throw new ArgumentOutOfRangeException("Liczba bitów wiadomości i liczba kolumn macierzy kodowej są różne.");
        }
        else
        {
            int wrongBitIndex = -1;
            int wrongBitIndex1 = -1;
            int wrongBitIndex2 = -1;
            // szukanie kolumny macierzy H identycznej do wektora błędu
            for (int i = 0; i < COLUMNS; i++)
            {
                bool identical = true;
                for (int j = 0; j < ROWS; j++)
                {
                    if (matrix_H[j, i] != errorVector[j])
                    {
                        identical = false;
                        break;
                    }
                }
                if (identical)
                {
                    wrongBitIndex = i;
                    break;
                }
            }
            // searching matrix columns which sum equals errorVector
            if (wrongBitIndex == -1)
            {
                for (int i = 0; i < COLUMNS - 1; i++)
                {
                    bool identical = false;
                    for (int j = i + 1; j < COLUMNS; j++)
                    {
                        identical = true;
                        for (int k = 0; k < ROWS; k++)
                        {                              
                            bool tmp1 = matrix_H[k, i] == 1;
                            bool tmp2 = matrix_H[k, j] == 1;
                            bool tmp3 = errorVector[k] == 1;
                            Console.WriteLine($"ijk=({i},{j},{k}        m[{k}, {i}] ^ m[{k},{j}]={tmp3 != tmp1 ^ tmp2}      errorVctor[{k}]={tmp3}");
                            if (tmp3 != tmp1 ^ tmp2)
                            {
                                //Console.WriteLine($"ijk=({i},{j},{k}        m[{k}, {i}] ^ m[{k},{j}]={tmp3 != tmp1 ^ tmp2}      errorVctor[{k}]={tmp3}");
                                identical = false; //XOR NA WYBRANYCH KOLUMNACH MACIERZY H - SPRAWDZENIE CZY SA 2 BLEDY
                                break;
                            }
                        }
                        if (identical)
                        {
                            //Console.WriteLine($"======IDENTICAL======\nij=({i},{j})");
                            wrongBitIndex1 = i;
                            wrongBitIndex2 = j;
                            i = COLUMNS;
                            break;
                        }
                    }
                    //if (identical)
                    //{
                    //    break;
                    //}
                }
            }

            if (wrongBitIndex != -1)
            {
                // korekcja jednego błędu
                FlipBit(message, wrongBitIndex);
                Console.Write($"Poprawiam 1 błąd na pozycji: {wrongBitIndex + 1}... ");
            }
            else if (wrongBitIndex1 != -1 && wrongBitIndex2 != -1)
            {
                // korekcja dwóch błędów
                FlipBit(message, wrongBitIndex1);
                FlipBit(message, wrongBitIndex2);
                Console.Write($"Poprawiam 2 błędy na pozycjach: {wrongBitIndex1 + 1} i {wrongBitIndex2 + 1}... ");
            }
            Console.WriteLine($"poprawnie zakodowana wiadomość ma postać:\n{Logic.ToString(message)}");
        }
    }

Полный код вы можете найти на моем github: https://github.com/janwadolowski/Tecommunication-hamming-code/blob/master/TiPS_1/TiPS_1/Logic.cs .

Я потратил столько времени на изучение этой функции, что больше не могу критически относиться к этому коду.