Robust and accurate Coreference Resolution (CR) is es­sential for many Natural Language Processing tasks, for example, Question Answering. However, not all types of anaphors can be successfully resolved by state-of-the-art CR systems. Typical pronoun resolution algorithms have an accuracy of up to 85 — 90% (Mitkov, 1999) whereas the performance of the best general coreference resolution systems is much lower: for example, (Soon et al., 2001) reported 60.4% F-score on the MUC-7 test data.

This leads to the conclusion that one should try to im­prove the resolution for the other major types of anaphors: proper names and definite noun phrases. Our experiments address a problem of coreference for named entities, in par­ticular, anaphoric links between two proper names. Ta­ble 1 shows several examples of coreferring proper names, demonstrating typical problems for automatic resolution.

There are several reasons to pay attention to this par­ticular sub-task. First, proper names represent a high pro­portion of all the anaphors: identifying correctly all the anaphoric links between NEs, we achieve 30% recall for the NP-Coreference task (only full NPs are considered as markables) in the set-based evaluation (cf. Section 6.2.).

Second, coreference resolution engines are usually not independent tools — they are integrated into various NLP applications. For example, a good CR module in a question answering system would allow us to keep track of entities, collecting and combining information from different sen­tences of the text. In this context coreference links between named entities become very important: they bring together various facts about real world objects that are likely to be mentioned in user's questions.

Third, accurate name matching algorithms can be help­ful for other tasks. For example, Branting (2002) points out that they are crucial for Legal Case-Management Systems.

In this paper we present various machine learning ex­periments evaluating strategies for name matching.

Virtually none of the previous approaches to the corefer­ence resolution task include any specific machine learning technique for resolving proper name anaphoric links. The most commonly used matching features for CR in general are same surface , same head, and contain (an anaphor is a substring of an antecedent). In our experiments we use the same surface matching as a baseline.

Soon et al. (2001) introduce the weak string identity feature (true if an anaphor and an antecedent have the same surface form after stripping offthe determiners).

Strube et al. (2002) propose two minimum edit dis­tance-based (MED) features. Although useful for German, they might be not so helpful for English because of its simpler morphology. To evaluate the role of approximate matching, we implemented a family of MED-based fea­tures.

Branting (2002) investigates name matching strate­gies for Legal Case-Management Systems, proposing tech­niques for abstracting over NPs and efficient indexing. Al­though we do some normalisation, following the ideas of (Branting, 2002) and (Soon et al., 2001), we are not inter­ested in further generalisation over the markables. Branting also uses exact and approximate matching and precompiled abbreviation tables. We do not use any external abbrevia­tion data, but compute possible abbreviations dynamically.

To sum it up, the commonly used approach is very sim­ple, and various previous studies show that it can be im­proved in many different ways. In this work we combine the ideas proposed in the literature with our own matching strategies.

For our experiments we use the MUC-7 coreference corpus (Hirschman and Chinchor, 1997). We parsed the texts with the (Charniak, 2000) parser and collected all the NPs, discarding complex ones (containing an embedded separately from all the other types ofanaphors.

We decompose our problem into three major sub-tasks: normalisation, substrings selection, and matching: one can, for example, compute minimum edit distance (matching) between the down-cased (normalisation) last nouns (sub­string) of an anaphor and an antecedent. The resulting value can be used as a similarity measure between the two.

Below we describe the algorithms we implemented to tackle these three sub-tasks. Several techniques are lan­guage specific, whereas others are relatively language inde­pendent (possibly applicable to any language with an alpha­betic script). Some algorithms are very fast, some (parser-based) require more processing, and some (Internet-based) are very time-consuming. In Section 6. we evaluate "lan­guage independent" and "fast" settings separately.

Normalisation. We use three normalisation functions: no_case, no .punctuation, and no determiner. The first one transforms a string into lower-case format. The second one strips off all the punctuation and auxiliary characters, and the last one strips off the determiner. The first two normali­sation techniques are relatively language independent. The third one is obviously language dependent: we need a list of all the determiners to perform this operation. However, we believe that such a list can be compiled very quickly for any particular language. One can combine these functions se­quentially, producing complex normalising algorithms. For example, no jcase&no punctuation of "that F-14" is "that f14". Finally, one can use several normalisations for the same markable to compute values for different features.

Substring selection. Some words in a name are more informative than others. Therefore it can be reasonable to compare not the whole strings, but only the most represen­tative parts of them. We implemented several algorithms for selecting most informative words.

The lastjioun algorithm outputs the last noun of the NP string. It requires a parser (or at least a tagger) and is language-dependent and moderately time-consuming.

Last is a simple modification of the lastjioun algorithm. It outputs the last word of the NP string. Although less accurate, it is faster and language independent.

First, a counterpart of last, is the first word of the NP.

The rarest algorithm outputs the least frequent word of the NP string: each word is sent to the AltaVista search en­gine and then the one that gets the lowest count (number of pages worldwide written in English) is returned. This algo­rithm is language independent, but very time-consuming.

As an example, the lastjioun and last substring of "Lockheed Martin Corp." is "Corp.", whereas the first and rarest substring is "Lockheed".

It does not make any sense to combine these algorithms sequentially, as they always output one word. However, one can use several of them at the same time: for example, our fast configurationuses both the first and the last algorithms.

Matching. We investigated the following string match­ing algorithms.

exactjnatch is a boolean function on two strings. It out­puts 1 if they are identical and 0 otherwise.

approximate jnatch: we implemented a family of algo­rithms, based on the minimum edit distance measure (Wag­ner and Fischer, 1974). Given two ordered sequences, the MED between them is defined as the number of insertions, deletions, and substitutions, needed to transform one into the other. We measure the distance between two strings ei­ther in symbols (MEDjs) or in words (MEDjv). In addition to the bare counts, we normalise our MED values by the length of an anaphor or an antecedent in symbols (length s) or in words (length jv). The formulas are shown in Table 2.

matchedjjart algorithms are generalisations of com­monly used contain feature (cf. Section 2.). They rep­resent the size of the overlap between two NPs. The ba­sic matchedjjart algorithm computes the number of sym­bols/words two NPs share. We normalise this count by the length of an anaphor or an antecedent in the same way as it is done for the approximate matching.

abbreviation: we have implemented several methods to resolve abbreviations, all of them comparing an anaphor (full string) to the lastjioun of candidate antecedents . The first algorithm (abbrev1) takes the initial letter of all the words in a string and produces a word out of them. This word is compared (by exact match) to the head of the sec­ond NP. The second algorithm (abbrev2) does the same, but ignores words, beginning with low-case letters. The algo­rithm abbrev3 checks whether it is possible to split the head of the second NP into small units, such that each unit is a beginning (prefix) of a word in the first NP, and the prefixes come in the right order (the same as the order of the cor­responding words). Finally, abbrev4 proceeds in the same way, but does not allow empty prefixes. The first two al­gorithms represent the most commonly used abbreviations. The last two algorithms are more general, allowing for non­trivial ways of abbreviating. Table 3 shows some examples.

Again, one cannot combine these algorithms sequen­tially, but it is possible to use several of them at the same time, computing values for different features.

All the techniques described above help us to build a feature set. We divide our features into two groups.

NP-based features, computed for both an anaphor and an antecedent, represent information about a single noun phrase. The features are represented in Table 4. However, we do not use all of these features in all the experiments.

Link-based features describe the similarity between two NP strings. The only exceptions are the sister and dis­tance features. The sister feature is set to 1 when two NPs are sister nodes in a parse tree and to 0 otherwise. Two distance features encode the distance between two named entities measured in terms of NPs and sentences.

The other features are represented by triples (normali­sation, substring selection, matching). Not all of them are useful. For example, the matched jjart algorithm with any substring selection would always produce the same values as exact jnatch with this substring. This observation re­duces the total number of features dramatically. Overall we have 135 features: 18 NP-based ones, sister,2 distances, and 114 features represented by matching triples.