Fabulous Adventures In Coding
Eric Lippert is a principal developer on the C# compiler team. Learn more about Eric.
Suppose you’ve got a huge mixed-up pile of white, black, green and red socks, with roughly equal numbers of each. You randomly choose two of them. What is the probability that they are a matched pair?
There are sixteen ways of choosing a pair of socks: WW, WB, WG, WR, BW, BB, … Of those sixteen pairs, four of them are matched pairs. So chances are 25% that you get a matched pair.
Suppose you choose three of them. What is the probability that amongst the socks you chose, there exists at least one matched pair?
Well, we already know that chances are 25% after you pick out just the first two. If you get a matched pair right off, great. If you don’t, then there are two colours in hand you might match. So the odds are going to be a lot better.
There are 64 ways of choosing three socks: WWW, WWB, … and so on. Of those 64 possible combinations, 40 of them have at least one matched pair, so that’s about a 63% chance.
Suppose you choose four. There are 256 possible combinations, 232 of which have at least one matched pairs, so that’s a 91% chance.
Of course by the time we get to five socks, we have a 100% chance of getting a pair; five socks, four colours, there have got to be two alike.
It might appear that we’ve slightly messed up the probabilities here because once you choose one white sock, odds are slightly better that the next sock you pick will not be white, since there are now fewer white socks in the pile. But if the pile is big enough then we can neglect this minor problem.
From now on we’ll call getting a matched pair a “collision”.
It seems clear that as we increase the number of possible sock colours, we decrease the probability of getting a collision in some sample size. And as we increase the size of the sample, we increase the probability of the sample containing a collision.
Suppose you have 365 different colours of socks - perhaps each sock has a number on it giving its colour number, so that we can tell them apart - and a pile of about six billion socks, with roughly equal numbers of each sock colour. What is the probability that we’ll get a collision if we pull out two socks at random? One in 365, clearly. Three socks? A little bit better than double that. And so on. To work out the exact probabilities we’d work out the number of possible combinations, and the number of those combinations that contain at least one collision.
Turns out that the point where you have a better than 50% chance of having a collision is 23 socks. This is the famous “birthday paradox”; if instead of 365 colours of socks we have 365 possible birthdays (ignoring leap years, the fact that more people are born on certain days than others, and so on) and we have a large group of people to choose from at random, then once you get to 23 people the odds are about fifty-fifty that two of them have the same birthday. By 50 people, chances are about 97% that two have the same birthday.
Which is maybe a nice party trick next time you’re at a party with 30 to 50 people – if you go around the room and ask everyone to say their birthday, odds are very good that two people will say the same day. But what’s my point?
Suppose you have just over four billion possible sock colours and a truly enormous supply of socks of each colour, such that each one is about equally likely. You start pulling socks out of the pile. What is the probability that you get a collision based on the number of socks you pull out? Four billion is an awfully big number compared to 4 or 365. What’s your intuition about the likelihood of a collision? How long until you have to start worrying about it?
Not nearly as long as you might think. I’ve worked out the math and summarized it in this handy log-log chart:
Man, is there anything better than getting a straight line on a log-log chart?
Anyway, you end up with a 1% chance of a collision after about 9300 tries, and a 50% chance after only 77000 tries. By the time you get into the mid six-digit numbers chances are for practical purposes 100% that there is a collision in there somewhere.
This is why it is a really bad idea to use 32 bit hash codes as “unique” identifiers. Hash values aren't random per se, but if they're well-distributed then they might as well be for our purposes. You might think “well, sure, obviously they are not truly unique since there are more than four billion possible values, but only four billion hash codes available. But there are so many possible hash values, odds are really good that I’m going to get unique values for my hashes”. But are the chances really that good? 9300 objects is not that many and 1% is a pretty high probability of collision.
Doesn't the same logic apply to GUIDs? But then what's the point of the GU part of the name?
(Basically, I'm hoping that you can tell me that there's something clever that GUIDs do to mitigate this issue)
Yes, there are two clever things. First, as Micah notes below, GUIDs are not exactly random; they are based in part on the current time and the MAC address of the network card in the machine. Since no two machines in the world have the same MAC address, and since time keeps on slippin' into the future, this for practical purposes guarantees that the GUID is unique in both time and space. (Machines that do not have network cards generate special GUIDs which are in a "known to be potentially not unique" range.)
See Raymond's article on this for more details:
Second, my article was about 32 bit hashes. GUIDs are 128 bits. Instead of four billion kinds of socks in the pile, there are over 250 billion billion billion billion kinds of socks. That space is enormous. So the logic continues to apply; as the size of the space gets bigger -- in this case, 64 billion billion billion times bigger -- the number of samples needed to make a collision likely gets a few billion billion times bigger too. -- Eric
GUID generators usually use time and MAC address to prevent collisions, but beyond that you could generate random 128 bit values until the heat death of the universe and be certain (enough) that you wouldn't get a collision.
The same problem would apply to GUIDs... technically; but the probability space for them is large enough that they are (probably) (close enough to) globally unique. It depends on how they are generated, and a host of other conditions.
Aside: From http://en.wikipedia.org/wiki/Birthday_attack , a 1% chance of collision on a (random) 128 bit value requires 2.6*10^18 samples... or 2.6 Exa-samples.
"There are sixteen ways of choosing a pair of socks: WW, WB, WG, WR, BW, BB, … Of those sixteen pairs, four of them are matched pairs. So chances are 25% that you get a matched pair."
Perhaps, but aren't you assuming that all the socks are the same type? What if some are children's socks, women's socks, etc.? What about wool socks and dress socks?
To complicate matters, there are also other types of socks that are not worn--wind socks, drift socks, etc.
Clearly more research needs to be done on this problem -- Eric
Was this considered when the GetHashCode method on System.Object was designed?
GetHashCode is not designed to provide a unique identifier; it's designed to make it fast and easy to balance a hash table. -- Eric
Also it's amazing that all of us commenters have the same silhouette!
I liked how you lead to your point. Way better imagining the problem by an example than the usual "yeah, be careful because you can get a hash-collision". Good writeup concerning an important topic.
The very same issue creeps up in database locking as well: http://rusanu.com/2009/05/29/lockres-collision-probability-magic-marker-16777215/. Because any lock is hashed into a simple 'resource' string, collisions are virtually guaranteed on large batches.
I made a hash of my sock draw too. The chances of me wearing the same coloured socks on any given day gets lower as time slips into the future.
Of course I meant "drawer" above. I made a hash of the joke too.
(no edit button - grumble grumble)
Interesting post and well articulated; however, I can't for the life of me figure out why someone would use a hash as an identifier. Frankly it's much more convenient to use a naturally occurring key or, if none exists, a generated GUID.
You can't imagine why anyone would do something cheap, trivial, fragile and wrong when a correct and robust solution could be implemented by doing work and applying rational thought? Apparently you are new to this planet; we have this thing called "human nature". :-) -- Eric
I'm just curious what piece of code led to this blog topic ;)
As noted below, this kind of thing comes up frequently on StackOverflow. Also, as one of my technical interview questions I pose a problem which requires the generation of a unique 32 bit integer; many people immediately go to random numbers or hash codes and are then unable to compute the probability of collision. -- Eric
Eric, "time keeps on slippin' into the future" sounds a lot like Steve Miller :-)
I suspect this post is motivated by a lot of people asking Eric "how do you make a good unique id with an int"
these same people are unlikely to be thinking of perfect hashes or some controlled sequence number (the only realistic solutions) they instead think GetHashcode() will do it for them.
You see quite a few of these on StackOverflow.
Add don't forget about the sock thief troll that has a fetish for blue socks...
This is a great article but doesn't necessarily help you out with a viable alternative. Some people often mistakenly turn to a hashcode (such as String.GetHashcode()) to generate an ID because they see it as random, alphanumeric, and they need something which isn't just a number. Integer IDs are a nightmare to replicate / merge with other database machines or staging environments in your infrastructure, for example.
For anyone who comes to this article from Twitter or a web search looking into the problem and who wants something high-performance that still supports replication, check out COMB GUIDs. It's based on an article written way back in 2002 by Jimmy Nillson (link as of March 2010 is here http://www.informit.com/articles/article.aspx?p=25862&seqNum=7) and luckily has been implemented into NHibernate as Guid.Comb generation method.