Kendall tau distance

Definition

The Kendall tau ranking distance between two lists \tau_1 and \tau_2 is K_d(\tau_1, \tau_2) = |{(i,j): i \tau_2(j) ] \vee \tau_1(i) \tau_1(j) \wedge \tau_2(i) where \tau_1(i) and \tau_2(i) are the rankings of the element i in \tau_1 and \tau_2 respectively.

K_d(\tau_1,\tau_2) will be equal to 0 if the two lists are identical and \frac{1}{2} n (n-1) (where n is the list size) if one list is the reverse of the other.

Kendall tau distance may also be defined as K_d(\tau_1,\tau_2) = \sum_{{i,j}\in P , i

where

• P is the set of unordered pairs of distinct elements in \tau_1 and \tau_2
• \bar{K}_{i,j}(\tau_1,\tau_2) = 0 if i and j are in the same order in \tau_1 and \tau_2
• \bar{K}_{i,j}(\tau_1,\tau_2) = 1 if i and j are in the opposite order in \tau_1 and \tau_2.

Kendall tau distance can also be defined as the total number of [discordant pairs.

Kendall tau distance in Rankings: A permutation (or ranking) is an array of N integers where each of the integers between 0 and N-1 appears exactly once.

The Kendall tau distance between two rankings is the number of pairs that are in different order in the two rankings. For example, the Kendall tau distance between 0 3 1 6 2 5 4 and 1 0 3 6 4 2 5 is four because the pairs 0-1, 3-1, 2-4, 5-4 are in different order in the two rankings, but all other pairs are in the same order.

The normalized Kendall tau distance K_n is \frac{K_d}{\frac{1}{2} n (n-1)} = \frac{2 K_d}{n (n-1)} and therefore lies in the interval [0,1].

If Kendall tau distance function is performed as K(L1,L2) instead of K(\tau_1,\tau_2) (where \tau_1 and \tau_2 are the rankings of L1 and L2 elements respectively), then triangular inequality is not guaranteed. The triangular inequality fails sometimes also in cases where there are repetitions in the lists. So then we are not dealing with a metric anymore.

Generalised versions of Kendall tau distance have been proposed to give weights to different items and different positions in the ranking.

Comparison to Kendall tau rank correlation coefficient

Main article: Kendall tau rank correlation coefficient

The  Kendall tau distance (K_d) must not be confused with the Kendall tau rank correlation coefficient (K_c)  used in statistics.

They are related by   K_c = 1 - 4 K_d /(n(n-1)) , K_d = (1 - K_c) (n(n-1))/4

Or simpler by  K_c = 1 - 2 K_n , K_n = (1-K_c)/2 where K_n is the normalised distance 2 K_d / (n(n-1)) see above)

The distance is a value between 0 and n(n-1) /2. (The normalised distance is between 0 and 1)

The correlation is between -1 and 1.

The distance between equals is 0, the correlation between equals is 1.

The distance between reversals is n(n-1) / 2 , the correlation between reversals is -1

For example comparing the rankings ABCD and ABCD the distance is 0 the correlation is 1.

Comparing the rankings ABCD and DCBA the distance is 6 the correlation is -1

Comparing the rankings ABCD and BDAC the distance is 3 the correlation is 0

Example

Suppose one ranks a group of five people by height and by weight:

Here person A is tallest and third-heaviest, B is the second -tallest and fourth-heaviest and so on.

In order to calculate the Kendall tau distance between these two rankings, pair each person with every other person and count the number of times the values in list 1 are in the opposite order of the values in list 2.

Since there are four pairs whose values are in opposite order, the Kendall tau distance is 4. The normalized Kendall tau distance is

: \frac{4}{5(5 - 1)/2} = 0.4.

A value of 0.4 indicates that 40% of pairs differ in ordering between the two lists.

Computing the Kendall tau distance

A naive implementation in Python (using NumPy) is:

import numpy as np

def normalised_kendall_tau_distance(values1, values2):
    """Compute the Kendall tau distance."""
    n = len(values1)
    assert len(values2) == n, "Both lists have to be of equal length"
    i, j = np.meshgrid(np.arange(n), np.arange(n))
    a = np.argsort(values1)
    b = np.argsort(values2)
    ndisordered = np.logical_or(np.logical_and(a[i] < a[j], b[i] > b[j]), np.logical_and(a[i] > a[j], b[i] < b[j])).sum()
    return ndisordered / (n * (n - 1))

However, this requires n^2 memory, which is inefficient for large arrays.

Given two rankings \tau_1,\tau_2, it is possible to rename the items such that \tau_1 = (1,2,3,...). Then, the problem of computing the Kendall tau distance reduces to computing the number of inversions in \tau_2—the number of index pairs i,j such that i while \tau_2(i) \tau_2(j). There are several algorithms for calculating this number.

• A simple algorithm based on merge sort requires time O(n \log n).
• A more advanced algorithm requires time O(n\sqrt{\log{n}}).

Here is a trivial C implementation.

float kendallTau(int * a, int * b, int n)
{
    int i, j, v = 0;

    for (j=1; j < n; j++)
        for (i=0; i < j; i++)
            v += (a[i] < a[j]) != (b[i] < b[j]);

    return v / ( 0.5*n*(n-1) );
}

References

References

1. "Sorting Applications".
2. Ravi Kumar and Sergei Vassilvitskii. (2010). "Generalized Distances between Rankings".
3. "calculating the number of "inversions" in a permutation".
4. (2010). "Proceedings of the Twenty-First Annual ACM-SIAM Symposium on Discrete Algorithms".