Hamming distance


 

In information theory, the Hamming distance between two strings of equal length is the number of positions at which the corresponding symbols are different. In another way, it measures the minimum number of substitutions required to change one string into the other, or the minimum number of errors that could have transformed one string into the other.
A major application is in coding theory, more specifically to block codes, in which the equallength strings are vectors over a finite field.
Examples
The Hamming distance between:
 "karolin" and "kathrin" is 3.
 "karolin" and "kerstin" is 3.
 1011101 and 1001001 is 2.
 2173896 and 2233796 is 3.
Properties
For a fixed length n, the Hamming distance is a metric on the set of the words of length n (also known as a Hamming space), as it fulfills the conditions of nonnegativity, identity of indiscernibles and symmetry, and it can be shown by complete induction that it satisfies the triangle inequality as well.^{[1]} The Hamming distance between two words a and b can also be seen as the Hamming weight of a−b for an appropriate choice of the − operator.
For binary strings a and b the Hamming distance is equal to the number of ones (population count) in a XOR b. The metric space of lengthn binary strings, with the Hamming distance, is known as the Hamming cube; it is equivalent as a metric space to the set of distances between vertices in a hypercube graph. One can also view a binary string of length n as a vector in by treating each symbol in the string as a real coordinate; with this embedding, the strings form the vertices of an ndimensional hypercube, and the Hamming distance of the strings is equivalent to the Manhattan distance between the vertices.
Error detection and error correction
The Hamming distance is used to define some essential notions in coding theory, such as error detecting and error correcting codes. In particular, a code C is said to be kerrors detecting if any two codewords c_{1} and c_{2} from C that have a Hamming distance less than k coincide; otherwise, a code is kerrors detecting if, and only if, the minimum Hamming distance between any two of its codewords is at least k+1.^{[1]}
A code C is said to be kerrors correcting if, for every word w in the underlying Hamming space H, there exists at most one codeword c (from C) such that the Hamming distance between w and c is less than k. In other words, a code is kerrors correcting if, and only if, the minimum Hamming distance between any two of its codewords is at least 2k+1. This is more easily understood geometrically as any closed balls of radius k centered on distinct codewords being disjoint.^{[1]} These balls are also called Hamming spheres in this context.^{[2]}
Thus a code with minimum Hamming distance d between its codewords can detect at most d1 errors and can correct ⌊(d1)/2⌋ errors.^{[1]} The latter number is also called the packing radius or the errorcorrecting capability of the code.^{[2]}
History and applications
The Hamming distance is named after Richard Hamming, who introduced it in his fundamental paper on Hamming codes Error detecting and error correcting codes in 1950.^{[3]} Hamming weight analysis of bits is used in several disciplines including information theory, coding theory, and cryptography.
It is used in telecommunication to count the number of flipped bits in a fixedlength binary word as an estimate of error, and therefore is sometimes called the signal distance.^{[4]} For qary strings over an alphabet of size q ≥ 2 the Hamming distance is applied in case of the qary symmetric channel, while the Lee distance is used for phaseshift keying or more generally channels susceptible to synchronization errors because the Lee distance accounts for errors of ±1.^{[5]} If q = 2 or q = 3 both distances coincide because Z/2Z and Z/3Z are also fields, but Z/4Z is not a field but only a ring.
The Hamming distance is also used in systematics as a measure of genetic distance.^{[6]}
However, for comparing strings of different lengths, or strings where not just substitutions but also insertions or deletions have to be expected, a more sophisticated metric like the Levenshtein distance is more appropriate.
Algorithm example
The Python3 function hammingDistance()
computes the Hamming distance between
two strings (or other iterable objects) of equal length, by creating a sequence of Boolean values indicating mismatches and matches between corresponding positions in the two inputs, and then summing the sequence with False and True values being interpreted as zero and one.
def hammingDistance(s1, s2):
"""Return the Hamming distance between equallength sequences"""
if len(s1) != len(s2):
raise ValueError("Undefined for sequences of unequal length")
return sum(el1 != el2 for el1, el2 in zip(s1, s2))
where the zip() function merges two equallength collections in pairs.
Or in Ruby language the function hammingDistance()
could be:
def hammingDistance(s1, s2)
raise "ERROR: Hamming: Non equal lengths" if s1.length != s2.length
(s1.chars.zip(s2.chars)).count {l, r l != r}
end
The following C function will compute the Hamming distance of two integers (considered as binary values, that is, as sequences of bits). The running time of this procedure is proportional to the Hamming distance rather than to the number of bits in the inputs. It computes the bitwise exclusive or of the two inputs, and then finds the Hamming weight of the result (the number of nonzero bits) using an algorithm of Wegner (1960) that repeatedly finds and clears the lowestorder nonzero bit. Some compilers support the __builtin_popcount function which can calculate this using specialized processor hardware where available.
int hamming_distance(unsigned x, unsigned y)
{
int dist = 0;
unsigned val = x ^ y;
// Count the number of bits set
while (val != 0)
{
// A bit is set, so increment the count and clear the bit
dist++;
val &= val  1;
}
// Return the number of differing bits
return dist;
}
Or, a much faster hardware alternative (for compilers that support builtins) is to use popcount like so.
int hamming_distance(unsigned x, unsigned y)
{
return __builtin_popcount(x ^ y);
}
//if your compiler supports 64bit integers
int hamming_distance(unsigned long long x, unsigned long long y)
{
return __builtin_popcountll(x ^ y);
}
See also
 Closest string
 Damerau–Levenshtein distance
 Euclidean distance
 Mahalanobis distance
 Jaccard index
 String metric
 Sørensen similarity index
 Word ladder
 Gray code
 Levenshtein distance
 sparse distributed memory
Notes
 1 2 3 4 Derek J.S. Robinson (2003). An Introduction to Abstract Algebra. Walter de Gruyter. pp. 255–257. ISBN 9783110198164.
 1 2 Cohen, G.; Honkala, I.; Litsyn, S.; Lobstein, A. (1997), Covering Codes, NorthHolland Mathematical Library, 54, Elsevier, pp. 16–17, ISBN 9780080530079
 ↑ Hamming (1950).
 ↑ Jose Ayala (2012). Integrated Circuit and System Design. Springer. p. 62. ISBN 9783642361562.
 ↑ Ron Roth (2006). Introduction to Coding Theory. Cambridge University Press. p. 298. ISBN 9780521845045.
 ↑ Pilcher, Wong & Pillai (2008).
References
 This article incorporates public domain material from the General Services Administration document "Federal Standard 1037C".
 Hamming, Richard W. (1950), "Error detecting and error correcting codes" (PDF), Bell System Technical Journal, 29 (2): 147–160, doi:10.1002/j.15387305.1950.tb00463.x, MR 0035935.
 Pilcher, C. D.; Wong, J. K.; Pillai, S. K. (March 2008), "Inferring HIV transmission dynamics from phylogenetic sequence relationships", PLoS Med., 5 (3): e69, doi:10.1371/journal.pmed.0050069, PMC 2267810, PMID 18351799.
 Wegner, Peter (1960), "A technique for counting ones in a binary computer", Communications of the ACM, 3 (5): 322, doi:10.1145/367236.367286.
 Ayala, Jose (2012), "Fast Propagation of Hamming and Signal Distances for RegisterTransfer Level Datapaths", Integrated Circuit and System Design, 1: 62.
Further reading
 MacKay, David J. C.. Information Theory, Inference, and Learning Algorithms Cambridge: Cambridge University Press, 2003. ISBN 0521642981