Is there a simple utility that you can take two lists of any kind of arbitrary
elements, such as a list of names, or even a flat list of words, and which will
output any elements held in common between the two lists?  

If a commonly known piece of software does this, could you explain the
process so that a dummy could do it?

The output need not be pretty, as long as it slows down the difficult and
tedious process of  manually looking at one list of names and looking
through another list of names to see if they're there.

The lists of names aren't in a real "database" format, just flat lists or
lists separated by commas.  I would prefer to get false positives for duplicates
than to miss an actual positives, since I don't want the duplicates to weed
them out, but to have a list of duplicates.

Some data might be in actual databases, some might be arbitrary lists
of proper names, some might have misspellings, have middle initials or
lack middle initials, or otherwise vary slightly.  I would like the duplicate
detection to be fuzzy.

I have found a number of theoretical discussions of such things and even
assignments to create such things in comp sci sylabbus sites using Google,
but nothing that seems to match what I'm looking for.  Sorting lists with the
sort function in Unix and then using join almost works for this purpose, but
not well enough and there's no way to make it fuzzy.  I've also found some
rather shitty suggestions from spammers of various sorts on merging
mailing lists, but they're generally more concerned with having large lists and
don't really care if 99% of it is utter rubbish.

It seems like the sort of thing that someone must do somewhere, and I'd
rather not recreate it if they have.  I don't care about the output's appearance
and a command line utility, python or perl script, or whatever will do.  
(It seems it should be possible to do this in MySQL too but I'm rather clueless
how to go about that.)

I am going to have to manually verify positives anyway, so this is just
something to speed up a tedious and time-consuming part of the process.