Hamming distance

Examples

The symbols may be letters, bits, or decimal digits, among other possibilities. For example, the Hamming distance between:

• "karolin" and "kathrin" is 3.
• "karolin" and "kerstin" is 3.
• "kathrin" and "kerstin" is 4.
• 0000 and 1111 is 4.
• 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 non-negativity, symmetry, the Hamming distance of two words is 0 if and only if the two words are identical, and it satisfies the triangle inequality as well: Indeed, if we fix three words a, b and c, then whenever there is a difference between the ith letter of a and the ith letter of c, then there must be a difference between the ith letter of a and ith letter of b, or between the ith letter of b and the ith letter of c. Hence the Hamming distance between a and c is not larger than the sum of the Hamming distances between a and b and between b and c. 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, much as the difference between two integers can be seen as a distance from zero on the number line.

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 length-n 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 ${\displaystyle {\mathbb{R}}^n}$ by treating each symbol in the string as a real coordinate; with this embedding, the strings form the vertices of an n-dimensional hypercube, and the Hamming distance of the strings is equivalent to the Manhattan distance between the vertices.

Error detection and error correction

The minimum Hamming distance or minimum distance (usually denoted by d_min) 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 k error detecting if, and only if, the minimum Hamming distance between any two of its codewords is at least k+1.

For example, consider a code consisting of two codewords "000" and "111". The Hamming distance between these two words is 3, and therefore it is k=2 error detecting. This means that if one bit is flipped or two bits are flipped, the error can be detected. If three bits are flipped, then "000" becomes "111" and the error cannot be detected.

A code C is said to be k-error 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 at most k. In other words, a code is k-errors correcting if the minimum Hamming distance between any two of its codewords is at least 2k+1. This is also understood geometrically as any closed balls of radius k centered on distinct codewords being disjoint. These balls are also called Hamming spheres in this context.

For example, consider the same 3-bit code consisting of the two codewords "000" and "111". The Hamming space consists of 8 words 000, 001, 010, 011, 100, 101, 110 and 111. The codeword "000" and the single bit error words "001","010","100" are all less than or equal to the Hamming distance of 1 to "000". Likewise, codeword "111" and its single bit error words "110","101" and "011" are all within 1 Hamming distance of the original "111". In this code, a single bit error is always within 1 Hamming distance of the original codes, and the code can be 1-error correcting, that is k=1. Since the Hamming distance between "000" and "111" is 3, and those comprise the entire set of codewords in the code, the minimum Hamming distance is 3, which satisfies 2k+1 = 3.

Thus a code with minimum Hamming distance d between its codewords can detect at most d-1 errors and can correct ⌊(d-1)/2⌋ errors. The latter number is also called the packing radius or the error-correcting capability of the code.

History and applications

The Hamming distance is named after Richard Hamming, who introduced the concept in his fundamental paper on Hamming codes, Error detecting and error correcting codes, in 1950. 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 fixed-length binary word as an estimate of error, and therefore is sometimes called the signal distance. For q-ary strings over an alphabet of size q ≥ 2 the Hamming distance is applied in case of the q-ary symmetric channel, while the Lee distance is used for phase-shift keying or more generally channels susceptible to synchronization errors because the Lee distance accounts for errors of ±1. If ${\displaystyle q=2}$ or ${\displaystyle q=3}$ both distances coincide because any pair of elements from $\mathbb{Z}/2\mathbb{Z}$ or $\mathbb{Z}/3\mathbb{Z}$ differ by 1, but the distances are different for larger ${\displaystyle q}$.

The Hamming distance is also used in systematics as a measure of genetic distance.

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 such as the Levenshtein distance may be more appropriate.

Algorithm example

The following function, written in Python 3, returns the Hamming distance between two strings:

<span id="mw8w"></span><span class="linenos" data-line="1" id="mw9A"></span><span class="k" id="mw9Q">def</span><span class="w" id="mw9g"> </span><span class="nf" id="mw9w">hamming_distance</span><span class="p" id="mw-A">(</span><span class="n" id="mw-Q">string1</span><span class="p" id="mw-g">:</span> <span class="nb" id="mw-w">str</span><span class="p" id="mw_A">,</span> <span class="n" id="mw_Q">string2</span><span class="p" id="mw_g">:</span> <span class="nb" id="mw_w">str</span><span class="p" id="mwAQA">)</span> <span class="o" id="mwAQE">-></span> <span class="nb" id="mwAQI">int</span><span class="p" id="mwAQM">:</span> <span class="linenos" data-line="2" id="mwAQQ"></span><span class="w" id="mwAQU"> </span><span class="sd" id="mwAQY">"""Return the Hamming distance between two strings."""</span> <span class="linenos" data-line="3" id="mwAQc"></span> <span class="k" id="mwAQg">if</span> <span class="nb" id="mwAQk">len</span><span class="p" id="mwAQo">(</span><span class="n" id="mwAQs">string1</span><span class="p" id="mwAQw">)</span> <span class="o" id="mwAQ0">!=</span> <span class="nb" id="mwAQ4">len</span><span class="p" id="mwAQ8">(</span><span class="n" id="mwARA">string2</span><span class="p" id="mwARE">):</span> <span class="linenos" data-line="4" id="mwARI"></span> <span class="k" id="mwARM">raise</span> <span class="ne" id="mwARQ">ValueError</span><span class="p" id="mwARU">(</span><span class="s2" id="mwARY">"Strings must be of equal length."</span><span class="p" id="mwARc">)</span> <span class="linenos" data-line="5" id="mwARg"></span> <span class="n" id="mwARk">dist_counter</span> <span class="o" id="mwARo">=</span> <span class="mi" id="mwARs">0</span> <span class="linenos" data-line="6" id="mwARw"></span> <span class="k" id="mwAR0">for</span> <span class="n" id="mwAR4">n</span> <span class="ow" id="mwAR8">in</span> <span class="nb" id="mwASA">range</span><span class="p" id="mwASE">(</span><span class="nb" id="mwASI">len</span><span class="p" id="mwASM">(</span><span class="n" id="mwASQ">string1</span><span class="p" id="mwASU">)):</span> <span class="linenos" data-line="7" id="mwASY"></span> <span class="k" id="mwASc">if</span> <span class="n" id="mwASg">string1</span><span class="p" id="mwASk">[</span><span class="n" id="mwASo">n</span><span class="p" id="mwASs">]</span> <span class="o" id="mwASw">!=</span> <span class="n" id="mwAS0">string2</span><span class="p" id="mwAS4">[</span><span class="n" id="mwAS8">n</span><span class="p" id="mwATA">]:</span> <span class="linenos" data-line="8" id="mwATE"></span> <span class="n" id="mwATI">dist_counter</span> <span class="o" id="mwATM">+=</span> <span class="mi" id="mwATQ">1</span> <span class="linenos" data-line="9" id="mwATU"></span> <span class="k" id="mwATY">return</span> <span class="n" id="mwATc">dist_counter</span>

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 lowest-order nonzero bit. Some compilers support the __builtin_popcount function which can calculate this using specialized processor hardware where available.

<span id="mwAUE"></span><span class="kt" id="mwAUI">int</span><span class="w" id="mwAUM"> </span><span class="nf" id="mwAUQ">hamming_distance</span><span class="p" id="mwAUU">(</span><span class="kt" id="mwAUY">unsigned</span><span class="w" id="mwAUc"> </span><span class="n" id="mwAUg">x</span><span class="p" id="mwAUk">,</span><span class="w" id="mwAUo"> </span><span class="kt" id="mwAUs">unsigned</span><span class="w" id="mwAUw"> </span><span class="n" id="mwAU0">y</span><span class="p" id="mwAU4">)</span> <span class="p" id="mwAU8">{</span> <span class="w" id="mwAVA"> </span><span class="kt" id="mwAVE">int</span><span class="w" id="mwAVI"> </span><span class="n" id="mwAVM">dist</span><span class="w" id="mwAVQ"> </span><span class="o" id="mwAVU">=</span><span class="w" id="mwAVY"> </span><span class="mi" id="mwAVc">0</span><span class="p" id="mwAVg">;</span> <span class="w" id="mwAVk"> </span><span class="c1" id="mwAVo">// The ^ operators sets to 1 only the bits that are different</span> <span class="w" id="mwAVs"> </span><span class="k" id="mwAVw">for</span><span class="w" id="mwAV0"> </span><span class="p" id="mwAV4">(</span><span class="kt" id="mwAV8">unsigned</span><span class="w" id="mwAWA"> </span><span class="n" id="mwAWE">val</span><span class="w" id="mwAWI"> </span><span class="o" id="mwAWM">=</span><span class="w" id="mwAWQ"> </span><span class="n" id="mwAWU">x</span><span class="w" id="mwAWY"> </span><span class="o" id="mwAWc">^</span><span class="w" id="mwAWg"> </span><span class="n" id="mwAWk">y</span><span class="p" id="mwAWo">;</span><span class="w" id="mwAWs"> </span><span class="n" id="mwAWw">val</span><span class="w" id="mwAW0"> </span><span class="o" id="mwAW4">></span><span class="w" id="mwAW8"> </span><span class="mi" id="mwAXA">0</span><span class="p" id="mwAXE">;</span><span class="w" id="mwAXI"> </span><span class="o" id="mwAXM">++</span><span class="n" id="mwAXQ">dist</span><span class="p" id="mwAXU">)</span> <span class="w" id="mwAXY"> </span><span class="p" id="mwAXc">{</span> <span class="w" id="mwAXg"> </span><span class="c1" id="mwAXk">// We then count the bit set to 1 using the Peter Wegner way</span> <span class="w" id="mwAXo"> </span><span class="n" id="mwAXs">val</span><span class="w" id="mwAXw"> </span><span class="o" id="mwAX0">=</span><span class="w" id="mwAX4"> </span><span class="n" id="mwAX8">val</span><span class="w" id="mwAYA"> </span><span class="o" id="mwAYE">&</span><span class="w" id="mwAYI"> </span><span class="p" id="mwAYM">(</span><span class="n" id="mwAYQ">val</span><span class="w" id="mwAYU"> </span><span class="o" id="mwAYY">-</span><span class="w" id="mwAYc"> </span><span class="mi" id="mwAYg">1</span><span class="p" id="mwAYk">);</span><span class="w" id="mwAYo"> </span><span class="c1" id="mwAYs">// Set to zero val's lowest-order 1</span> <span class="w" id="mwAYw"> </span><span class="p" id="mwAY0">}</span> <span class="w" id="mwAY4"> </span><span class="c1" id="mwAY8">// Return the number of differing bits</span> <span class="w" id="mwAZA"> </span><span class="k" id="mwAZE">return</span><span class="w" id="mwAZI"> </span><span class="n" id="mwAZM">dist</span><span class="p" id="mwAZQ">;</span> <span class="p" id="mwAZU">}</span>

A faster alternative is to use the population count (popcount) assembly instruction. Certain compilers such as GCC and Clang make it available via an intrinsic function:

<span id="mwAZo"></span><span class="c1" id="mwAZs">// Hamming distance for 32-bit integers</span> <span class="kt" id="mwAZw">int</span><span class="w" id="mwAZ0"> </span><span class="nf" id="mwAZ4">hamming_distance32</span><span class="p" id="mwAZ8">(</span><span class="kt" id="mwAaA">unsigned</span><span class="w" id="mwAaE"> </span><span class="kt" id="mwAaI">int</span><span class="w" id="mwAaM"> </span><span class="n" id="mwAaQ">x</span><span class="p" id="mwAaU">,</span><span class="w" id="mwAaY"> </span><span class="kt" id="mwAac">unsigned</span><span class="w" id="mwAag"> </span><span class="kt" id="mwAak">int</span><span class="w" id="mwAao"> </span><span class="n" id="mwAas">y</span><span class="p" id="mwAaw">)</span> <span class="p" id="mwAa0">{</span> <span class="w" id="mwAa4"> </span><span class="k" id="mwAa8">return</span><span class="w" id="mwAbA"> </span><span class="n" id="mwAbE">__builtin_popcount</span><span class="p" id="mwAbI">(</span><span class="n" id="mwAbM">x</span><span class="w" id="mwAbQ"> </span><span class="o" id="mwAbU">^</span><span class="w" id="mwAbY"> </span><span class="n" id="mwAbc">y</span><span class="p" id="mwAbg">);</span> <span class="p" id="mwAbk">}</span> <span class="c1" id="mwAbo">// Hamming distance for 64-bit integers</span> <span class="kt" id="mwAbs">int</span><span class="w" id="mwAbw"> </span><span class="nf" id="mwAb0">hamming_distance64</span><span class="p" id="mwAb4">(</span><span class="kt" id="mwAb8">unsigned</span><span class="w" id="mwAcA"> </span><span class="kt" id="mwAcE">long</span><span class="w" id="mwAcI"> </span><span class="kt" id="mwAcM">long</span><span class="w" id="mwAcQ"> </span><span class="n" id="mwAcU">x</span><span class="p" id="mwAcY">,</span><span class="w" id="mwAcc"> </span><span class="kt" id="mwAcg">unsigned</span><span class="w" id="mwAck"> </span><span class="kt" id="mwAco">long</span><span class="w" id="mwAcs"> </span><span class="kt" id="mwAcw">long</span><span class="w" id="mwAc0"> </span><span class="n" id="mwAc4">y</span><span class="p" id="mwAc8">)</span> <span class="p" id="mwAdA">{</span> <span class="w" id="mwAdE"> </span><span class="k" id="mwAdI">return</span><span class="w" id="mwAdM"> </span><span class="n" id="mwAdQ">__builtin_popcountll</span><span class="p" id="mwAdU">(</span><span class="n" id="mwAdY">x</span><span class="w" id="mwAdc"> </span><span class="o" id="mwAdg">^</span><span class="w" id="mwAdk"> </span><span class="n" id="mwAdo">y</span><span class="p" id="mwAds">);</span> <span class="p" id="mwAdw">}</span>