In this article, we continue where we left off and focus solely on error detection for Hamming code.

Error Correction

Utilizing Hamming(7,4) encoding allows us to detect double-bit errors and even correct single-bit ones!

During the encoding, we only add parity bits, so the happy path decoding scenario involves stripping the message of the parity bits, which reside at known indexes (1,2,4…n, 2n):

fun stripHammingMetadata(input: EncodedString): BinaryString {
    return input.value.asSequence()
        .filterIndexed {
            i,
            _ - > (i + 1).isPowerOfTwo().not()
        }
        .joinToString("")
        .let(::BinaryString)
}

This is rarely the case because, since we made effort to calculate parity bits, we want to leverage them first.

The codeword validation is quite intuitive if you already understand the encoding process. We simply need to recalculate all parity bits and do the parity check (check if those values match what’s in the message):

private fun indexesOfInvalidParityBits(input: EncodedString): List < Int > {
    fun toValidationResult(it: Int, input: EncodedString): Pair < Int,
    Boolean > =
    helper.parityIndicesSequence(it - 1, input.length)
    .map {
        v - > input[v].toBinaryInt()
    }
    .fold(input[it - 1].toBinaryInt()) {
        a,
        b - > a xor b
    }
    .let {
        r - > it to(r == 0)
    }

    return generateSequence(1) {
            it * 2
        }
        .takeWhile {
            it < input.length
        }
        .map {
            toValidationResult(it, input)
        }
        .filter {
            !it.second
        }
        .map {
            it.first
        }
        .toList()
}

If they all match, then the codeword does not contain any errors:

override fun isValid(codeWord: EncodedString) =
    indexesOfInvalidParityBits(input).isEmpty()

Now, when we already know the message was transmitted incorrectly, we can request the sender to retransmit the message… or try to correct it ourselves.

Finding the distorted bit is as easy as summing the indexes of invalid parity bits – the result is the index of the faulty one. In order to correct the message, we can simply flip the bit:

override fun decode(codeWord: EncodedString): BinaryString =
    indexesOfInvalidParityBits(codeWord).let {
        result - >
            when(result.isEmpty()) {
                true - > codeWord
                false - > codeWord.withBitFlippedAt(result.sum() - 1)
            }.let {
                extractor.stripHammingMetadata(it)
            }
    }

We flip the bit using an extension:

private fun EncodedString.withBitFlippedAt(index: Int) = this[index].toString().toInt()
    .let {
        this.value.replaceRange(index, index + 1, ((it + 1) % 2).toString())
    }
    .let(::EncodedString)

We can see that it works by writing a homemade property test:

@Test
fun shouldEncodeAndDecodeWithSingleBitErrors() = repeat(10000) {
    randomMessage().let {
        assertThat(it).isEqualTo(decoder.decode(encoder.encode(it)
            .withBitFlippedAt(rand.nextInt(it.length))))
    }
}

Unfortunately, Hamming (7,4) does not distinguish between codewords containing one or two distorted bits. If you try to correct the two-bit error, the result will be incorrect.

Disappointing, right? This is what drove the decision to make use of an additional parity bit and create the Hamming (8,4).

Conclusion

We’ve seen how the error correction for Hamming codes look like and went through the extensive off-by-one-error workout.

Code snippets can be found on GitHub.