pair-wise entity resolution: overview and challenges. information integration is one of the oldest and most important computer science problems: information from diverse sources must be combined, so that users can access and manipulate the information in a unified way. one of the central problems in information integration is that of entity resolution (er) (sometimes referred to as deduplication). er is the process of identifying and merging incoming records judged to represent the same real-world entity.for example, consider a company that has different customer databases (e.g., one for each subsidiary), and would like to integrate them. identifying matching records is challenging because there are no unique identifiers across the different sources or databases. a given customer may appear in different ways in each database, and there is a fair amount of guesswork in determining which customers match. deciding if records match is often computationally expensive, e.g., may involve finding maximal common subsequences in two strings. how to combine matching records is often also application dependent. for example, say different phone numbers appear in two records to be merged. in some cases we may wish to keep both of them, while in others we may want to pick just one as the "consolidated" number.another source of complexity is that newly merged records may match with other records. for instance, when we combine records r1 and r2 we may obtain a record r12 that now matches r3. the original records, r1 and r2, may not match with r3, but because r12 contains more information about the same real-word entity that r1 and r2 represent, the "connection" to r3 may now be apparent. such "chained" matches imply that new merged records must be recursively compared to all records.there are many ways to perform er, but in this talk i will explore only one general approach, where the decision of what records represent the same real-world entity is done in a pair-wise fashion. furthermore, we assume that the matching is done by a "black-box" function, which makes our approach generic and applicable to many domains. thus, given two records, r1 and r2, the match function m(r1, r2) returns true if there is enough evidence in the two records that they both refer to the same real-world entity. we also assume a black-box merge function that combines a pair of matching records.in this talk i will discuss the advantages and disadvantages of such a generic, pair-wise approach to er. and even though the approach is relatively simple, there are still many interesting challenges. for instance, how can one minimize the number of invocations to the match and merge black-boxes? are there any properties of the functions that can significantly reduce the number of calls? if one has available multiple processors, how can one distribute the computational load? if records have confidences associated with them, how does the problem complexity change, and how can we efficiently find the confidence of the resolved records? in the talk i will address these challenges, and report on some preliminary work we have done at stanford. (this stanford work in joint with omar benjelloun, tyson condie, johnson (heng) gong, jeff jonas, hideki kawai, tait e. larson, david menestrina, nicolas pombourcq, qi su, steven whang, jennifer widom.for additional information on er and our stanford serf project, please visit http://www-db.stanford.edu/serf/.