Question

I am wondering if there is a way to generate a key based on the relationship between two entities in a way that the key for relationship a->b is the same as the key for relationship b->a.

Desirably this would be a hash function which takes either relationship member but generates the same output regardless of the order the members are presented in.

Obviously you could do this with numbers (e.g. add(2,3) is equivalent to add(3,2)). The problem for me is that I do not want add(1,4) to equal add(2,3). Obviously any hash function has overlap but I mean a weak sense of uniqueness.

My naive (and performance undesirable) thought is:

function orderIndifferentHash(string val1, string val2)
{
  return stringMerge(hash(val1), hash(val2));
  /* String merge will 'add' each character (with wrapping).
     The pre-hash is to lengthen strings to at least 32 characters */
}

Answer 1

You you are after:

Some function f(x, y) such that

• f(x, y) == f(y, x)
• f(x, y) != f(a, b) => (x == a and y == b) or (x == b and y == a)

There are going to be absolutely loads of these – off hand the one I can think of is “sorted concatenation”:

1. Sort (x, y) by any ordering
2. Apply a hash function u(a) to x and y individually (where u(a) == u(b) implies a == b, and the length of u(a) is constant)
3. Concatenate u(x) and u(y).

In this case:

If x == y then then the two hashes are trivially the same, so without loss of generality x < y, hence:

• f(y, x) = u(x) + u(y) = f(x, y)

Also, if f(x, y) == f(a, b), this means that either:

• u(x) == u(a) and u(y) == u(b) => x == a and y == b, or
• u(y) == u(a) and u(x) == u(b) => y == a and x == b

Short version:

Sort x and y, and then apply any hash function where the resulting hash length is constant.