File Information
File: 05-lr/acl_arc_1_sum/cleansed_text/xml_by_section/metho/03/j03-4001_metho.xml
Size: 63,063 bytes
Last Modified: 2025-10-06 14:08:06
<?xml version="1.0" standalone="yes"?> <Paper uid="J03-4001"> <Title>c(c) 2003 Association for Computational Linguistics Dependency Parsing with an Extended Finite-State Approach</Title> <Section position="5" start_page="519" end_page="521" type="metho"> <SectionTitle> 4. Turkish </SectionTitle> <Paragraph position="0"> Turkish is an agglutinative language in which a sequence of inflectional and derivational morphemes get affixed to a root (Oflazer 1993). At the syntax level, the unmarked constituent order is Subject-Object-Verb, but constituent order may vary as demanded by the discourse context. Essentially all constituent orders are possible, especially at the main sentence level, with very minimal formal constraints. In written text, however, the unmarked order is dominant at both the main-sentence and embedded-clause level.</Paragraph> <Paragraph position="1"> Turkish morphophonology is characterized by a number of processes such as vowel harmony (vowels in suffixes, with very minor exceptions, agree with previous 1 See section 6 for how projectivity is checked and section 6.5 on the implications of checking for projectivity during parsing with both right-to-left and left-to-right dependency links.</Paragraph> <Paragraph position="2"> Computational Linguistics Volume 29, Number 4 vowels in certain aspects), consonant agreement, and vowel and consonant ellipsis. The morphotactics are quite complicated: A given word form may involve multiple derivations (as we show shortly). The number of word forms one can generate from a nominal or verbal root is theoretically infinite (see, e.g., Hankamer, [1989]). Derivations in Turkish are very productive, and the syntactic relations that a word is involved in as a dependent or head element are determined by the inflectional properties of the one or more (possibly intermediate) derived forms. In this work, we assume that a Turkish word is represented as a sequence of inflectional groups (IGs), separated by ^DBs, denoting derivation boundaries, in the following general form:</Paragraph> <Paragraph position="4"> denotes relevant inflectional features including the part of speech for the root, for the first IG, and for any of the derived forms. For instance, the derived modifier saVglamla,stirdiVgimizdaki would be represented as The first shows the root word along with its part of speech, which is its only inflectional feature. The second IG indicates a derivation into a verb whose semantics is &quot;to become&quot; the preceding adjective. The +Become can be thought of as a minor part-of-speech tag. The third IG indicates that a causative verb with positive polarity is derived from the previous verb. The fourth IG indicates the derivation of a nominal form, a past participle, with +Noun as the part of speech and +PastPart. It has has other inflectional features: +A3sg for third-person singular, +P3sg for third-person singular possessive agreement, and +Loc for locative case. Finally the fifth IG indicates a derivation into an adjective.</Paragraph> <Paragraph position="5"> A sentence would then be represented as a sequence of the IGs making up the words. An interesting observation that we can make about Turkish is that, when a word is considered as a sequence of IGs, syntactic relation links emanate only from the last IG of a (dependent) word and land on one of the IGs of a (head)word on the 2 Literally, '(the thing existing) at the time we caused (something) to become strong'. Obviously this is not a word that one would use everyday. Turkish words found in typical text average three to four morphemes including the stem, with an average of about 1.7 derivations per word. 3 The morphological features other than the obvious part-of-speech features are +Become: become verb, +Caus: causative verb, PastPart: derived past participle, P3sg: third-person singular possessive agreement, A3sg: third-person singular number-person agreement, +Zero: zero derivation with no overt morpheme, +Pnon: no possessive agreement, +Loc: locative case, +Pos: positive polarity.</Paragraph> <Section position="1" start_page="521" end_page="521" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> right (with minor exceptions), as exemplified in Figure 2. A second observation is that, with minor exceptions, the dependency links between the IGs, when drawn above the IG sequence, do not cross.</Paragraph> <Paragraph position="1"> Figure 3 shows a dependency tree for a Turkish sentence laid on top of the words segmented along IG boundaries. It should be noted that all IGs that link to the same head IG comprise a constituent, and the legality of a link depends primarily on the inflectional features of the IGs it connects. For the purposes of this article we can summarize aspects of Turkish as follows: * The IGs are the &quot;words.&quot; That is, we treat a chunk of (free and bound) inflectional morphemes as the units that we relate with dependency links.</Paragraph> <Paragraph position="2"> * Within a word, the IGs are linearly dependent on the next IG, if any. We would not, however, show and deal with these explicitly, but rather deal only with the dependency link emanating from the last IG in each word, which is the syntactic head of the word (whereas the first IG which contains the root is the semantic head).</Paragraph> </Section> </Section> <Section position="6" start_page="521" end_page="522" type="metho"> <SectionTitle> 4 Such cases would be violating the projectivity constraint. The only examples of such crossing that we </SectionTitle> <Paragraph position="0"> know are certain discontinuous noun phrases in which an adverbial modifier of the matrix verb intervenes between a specifier and the rest of the noun phrase. Since the specifier links to the head noun but the adverbial links to the verb, the links have to cross.</Paragraph> <Paragraph position="1"> Computational Linguistics Volume 29, Number 4 * For all practical purposes the syntactic dependency links go from left to right, that is, the core structure is subject-object-verb, and modifiers precede their heads.</Paragraph> </Section> <Section position="7" start_page="522" end_page="522" type="metho"> <SectionTitle> 5. Finite-State Transducers </SectionTitle> <Paragraph position="0"> The exposition in the subsequent sections will make extensive use of concepts from finite-state transducers. In this section, we provide a brief overview of the main relevant concepts; the reader is referred to recent expositions (e.g., Roche and Schabes [1997]; also, Hopcroft and Ullman [1979] provides a detailed exposition of finite-state machines and regular languages.) Finite-state transducers are finite-state devices with transitions labeled by pairs of symbols (u:l), u denoting the &quot;upper&quot; symbol and l denoting the &quot;lower&quot; symbol. These symbols come from a finite alphabet. Additionally, either u or l (but not both) can be the epsilon1 symbol, denoting the empty string. A finite-state transducer T maps between two regular languages: U, the &quot;upper&quot; language, and L, the &quot;lower&quot; language. The mapping is bidirectional, and in general, a string in one of the languages may map to one or more strings in the other language. The transductions in both directions are valid only if the string on the input side takes the finite-state transducer to a final state.</Paragraph> <Paragraph position="1"> The behavior of finite-state transducers can also be described using regular expressions over an alphabet of symbols of the form (u:l) (including symbols epsilon1:l and u:epsilon1), in complete analogy to regular expressions for finite-state recognizers. Since the notational mechanisms provided by the basic definition of regular expressions (concatenation, union, and Kleene star [Hopcroft and Ullman 1979]) are quite restricted and low level, developers of finite-state transducer manipulation systems have augmented the notational capabilities with operations at a much higher level of abstraction, much closer to the operations used by the computational linguistics application (see, e.g., Karttunen et al., [1996]; see also http://www.xrce.xerox.com/competencies/contentanalysis/fsCompiler/fssyntax.html, and also van Noord, [1997]). Finite-state transducers are closed under union, but in contrast to finite-state recognizers, they are not closed under difference and intersection operations (Kaplan and Kay 1994). On the other hand, finite-state transducers are closed under the operation of composition, which is very much an analog of function composition in algebra. Let if and only if [?]z such that (x, z) [?] T</Paragraph> <Paragraph position="3"> is not the same mapping as T</Paragraph> </Section> <Section position="8" start_page="522" end_page="522" type="metho"> <SectionTitle> * T </SectionTitle> <Paragraph position="0"> . Figure 4 summarizes the main points of the composition operation for finite-state transducers.</Paragraph> </Section> <Section position="9" start_page="522" end_page="523" type="metho"> <SectionTitle> 6. Finite-State Dependency Parsing </SectionTitle> <Paragraph position="0"> Our approach is based on constructing a graphic representation of the dependency structure of a sentence, including the lexical items and the labeled directed arcs en5 Notationally, for a transducer T, we take T(U) to mean the transduction from the upper to the lower language and T [?]1 to mean the transduction from the lower to the upper language.</Paragraph> <Section position="1" start_page="523" end_page="523" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> Figure 4 Composition operation for finite-state transducers. Figure 5 Physical representation and logical view of channels and dependency links. coding the dependency relations. In constructing this dependency graph, these labeled links are represented by additional symbols that are laid out within the symbols representing the lexical items and their morphological features. The approach relies on augmenting the input with &quot;channels&quot; that (logically) reside above the IG sequence and &quot;laying&quot; links representing dependency relations in these channels, as depicted in Figure 5(a). The input to the parser is a representation of the sentence as a sequence (or a lattice, if morphological disambiguation has not been performed) of IGs with some additional symbols to delineate certain boundaries. The</Paragraph> </Section> </Section> <Section position="10" start_page="523" end_page="540" type="metho"> <SectionTitle> 6 The lattice of all morphological analyses of the words in a sentence can be encoded by a finite-state </SectionTitle> <Paragraph position="0"> acceptor. In fact, one gets such an acceptor when a nondeterministic morphological analysis finite-state transducer is applied to the input. Further, finite-state acceptors are assumed to be coerced into identity transducers that map the input strings they accept to identical output strings. This coercion is necessary so that filters defined as acceptors can be used as transducers with the composition operators.</Paragraph> <Paragraph position="1"> Computational Linguistics Volume 29, Number 4 Figure 6 Channel symbol slots around an inflectional group.</Paragraph> <Paragraph position="2"> parser operates in a number of iterations: At each iteration of the parser, a new empty channel is &quot;stacked&quot; on &quot;top&quot; of the input, and any possible links are established using these channels.</Paragraph> <Paragraph position="3"> Parsing terminates when no new links can be established within the most recent channel added, that is, when a fixed point is reached. In this respect, this approach is similar to that of Roche (1997). An abstract view of this is presented in panels (a) through (c) of Figure 5.</Paragraph> <Section position="1" start_page="524" end_page="525" type="sub_section"> <SectionTitle> 6.1 Representing Channels and Syntactic Relations </SectionTitle> <Paragraph position="0"> The sequence (or the lattice) of IGs is produced by a morphological analysis transducer, with each IG initially being augmented by two pairs of delimiter symbols, as <(IG)>.</Paragraph> <Paragraph position="1"> The ( and ) pair separates the morphological features from the channel representation symbols, while < and > separate the representations of consecutive IGs. Word-final IGs (IGs from which links will emanate) are further augmented with a special marker @.</Paragraph> <Paragraph position="2"> Channels are represented by pairs of matching symbols that are inserted between the <...( and the )...> delimiter symbols. Symbols for new channels (upper channels in Figure 5) are stacked so that the symbols for the topmost channels are those closest to the (...), and in this way dependency links do not cross when drawn (see Figure 6).</Paragraph> <Paragraph position="3"> At any time, the number of channel symbols on both sides of an IG is the same.</Paragraph> <Paragraph position="4"> Multiple dependency links can occupy mutually exclusive segments of a channel as long as they do not interfere with each other; that is, each channel may accommodate many dependency links whenever possible.</Paragraph> <Paragraph position="5"> How a certain segment of channel is used is indicated by various symbols surrounding the IGs, within the < and > delimiters:</Paragraph> </Section> <Section position="2" start_page="525" end_page="525" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> The following syntactic relations are currently encoded in the channels: 1. Subject (s/S) 2. Object (o/O) 3. Modifier (adverbs/adjectives) (m/M)) 4. Possessor (p/P) 5. Classifier (c/C) 6. Determiner (d/D) 7. Dative adjunct (t/T) 8. Ablative adjunct (f/F) 9. Locative adjunct (l/L) 10. Instrumental adjunct (i/I) The lowercase symbol in each case is used to indicate the start of a link, and the uppercase symbols indicate the end of a link. Both kinds of symbols are used to encode configurational and linguistic constraints on IGs, as we show later. For instance, with three channels, the dependency structure of the IGs of bu eski evdeki g&quot;ul&quot;un (of the rose at this old house) in Figure 3 would be represented as</Paragraph> <Paragraph position="2"> The M and the D to the left of the first IG of evdeki (third IG above) indicate the incoming modifier and determiner links from the first two IGs, matching the start symbols m and d in the second and the first IGs. The m--M pair encodes the modifier link from eski (old) to evde (at house), and the d--D pair encodes the determiner link from bu (this) to evde. The last IG above has an M on the left side matching the m in the IG to the left. This m--M pair encodes the modifier relation between +ki and g&quot;ul&quot;un (of the rose). The last IG above has an outgoing possessor link marked by the p on its right side, indicating that it is a genitive-marked possessor of some other IG to the right.</Paragraph> <Paragraph position="3"> We should note, however, that the (morphological) relations between IGs that make up a single word are not at all a concern here and are not considered to be syntactic dependency relations. Thus they are never explicitly shown or encoded except by virtue of their being sequentially placed in the input. The only links that we explicitly encode are those links emanating from a word-final IG and landing on some other IG.</Paragraph> </Section> <Section position="3" start_page="525" end_page="526" type="sub_section"> <SectionTitle> 6.2 Components of the Parser </SectionTitle> <Paragraph position="0"> The basic strategy of a parser iteration is to recognize, by means of a rule (encoded as a regular expression), a dependent IG and a head IG and link them by modifying the &quot;topmost&quot; channel between the two. Once we identify the dependent IG and the head IG (in a manner to be described shortly), we proceed as follows: The second step above deserves some more attention, as it has additional functions besides identifying the relevant IGs. One should be careful to avoid generating strings that are either illegal or redundant or cannot lead to a valid parse at the end of the iterations. Thus, the second step makes sure that 1. The last channel in the segment to be bracketed is free.</Paragraph> <Paragraph position="1"> 2. The dependent is not already linked at one of the lower channels (since an IG can be the dependent of only one other IG).</Paragraph> <Paragraph position="2"> 3. None of the channels directly underneath the segment have any links coming into or going out of the projection, in those channels, of the segment bracketed. This makes sure that there are no crossing links. It is obviously okay to have links that start and terminate in lower channels within the projection of the bracketed segment.</Paragraph> <Paragraph position="3"> 9 4. There are no channels below the current channel that are unused in the segment to be bracketed (if there are, then this link could have been made there.) 5. The link to be established does not trap an unlinked word-final IG. If there is such an IG, its future link would have to cross the link to be established in the current segment.</Paragraph> <Paragraph position="4"> The last three of these constraints are depicted in Figure 7.</Paragraph> </Section> <Section position="4" start_page="526" end_page="527" type="sub_section"> <SectionTitle> 6.3 Rules for Establishing Dependency Links </SectionTitle> <Paragraph position="0"> The components of a dependency link are recognized using regular expressions. These regular expressions identify the dependent IG, the head IG, and the IGs in between to be skipped over, and they temporarily bracket the input segment including these IGs.</Paragraph> <Paragraph position="1"> 9 It is actually possible to place a crossing link by laying it in a special channel below the IG sequence so that it would not interfere with the other links. This would necessitate additional delimiter symbols and would unnecessarily further complicate the presentation.</Paragraph> </Section> <Section position="5" start_page="527" end_page="530" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> Configurations to be avoided during parsing.</Paragraph> <Paragraph position="1"> These regular expressions correspond to &quot;grammar rules,&quot; and a collection of these rules comprise the dependency grammar.</Paragraph> <Paragraph position="2"> A typical rule looks like the following: [ LR [ML IGMiddle MR]* RL ] (->) &quot;{Rel&quot; ... &quot;Rel}&quot; ||IGDep IGHead This rule is an example of a XRCE optional-replace rule that nondeterministically inserts the curly braces on the right-hand side (the symbols on both sides of the ellipsis) into the output string in the lower language, around any part of the input string in the upper language that matches its left-hand side, provided the left-hand side is contextually constrained on the left by IGDep and on the right by IGHead. This replace rule can nondeterministically make multiple nonoverlapping replacements. The left-hand side of this rule (to the left of (->)) has three components: The first part, LR, specifies the constraints on the right-hand side of the dependent IG. The second part, [ML IGMiddle MR]*, defines any middle IGs that will be ignored 10 We use the XRCE regular expression language syntax; the [ and ] act like parentheses used as grouping operators in the language. See http://www.xrce.xerox.com/competencies/contentanalysis/fsCompiler/fssyntax.html for details. 11 An earlier implementation of the parser used a slightly different optional-replace rule that did not make use of the contextual constraint, as the new format was not included in the toolkit available to the author. A typical rule there looked like [[LL IGDep LR] [ML IGMiddle MR]* [RL IGHead RR]] (->) &quot;{Rel&quot; ... &quot;Rel}&quot;. Although for the purposes of writing the dependency grammar, the old rule format was more transparent, its use necessitated some extra complexity in various other components of the parser. The old rule format has been abandoned in favor of the new format. I thank an anonymous reviewer for suggesting the use of this new rule format.</Paragraph> <Paragraph position="3"> Computational Linguistics Volume 29, Number 4 and skipped over, and the third part, RL, specifies the contraints on the left-hand side channel symbols of the head IG. The head and dependent IG patterns IGDep and IGHead are specified as left and right contextual constraints on the pattern of the three components specified on the left-hand side.</Paragraph> <Paragraph position="4"> This rule (optionally) brackets (with {Rel and Rel}) any occurrence of pattern LR [ML IGMiddle MR] RL provided the pattern IGDep is to the left of LR and the pattern IGHead is to the right of RL.</Paragraph> <Paragraph position="5"> After the (optional) bracketing, the brace {Rel occurs between IGDep and LR, and the brace Rel} occurs between RL and IGHead. Each rule has its own brace symbol depending on the relationship of the dependent and the head. The optionality is necessary because a given IG may be related to multiple IGs as a result of syntactic ambiguities, and all such links have to be produced to arrive at the final set of parses. It should also be noted that there are rules that deviate from the template above in that the segment to be skipped may be missing, or may contain barrier patterns that should not be skipped over, etc.</Paragraph> <Paragraph position="6"> The symbols L(eft)R(ight), M(iddle)L, MR, and RL are regular expressions that encode constraints on the bounding channel symbols that are used to enforce some of the configurational constraints described earlier. Let</Paragraph> <Paragraph position="8"> These four regular expressions are defined as follows: 1. The regular expression LR = [&quot;@&quot; &quot;)&quot; &quot;0&quot; [&quot;0&quot;]* &quot;>&quot; ] checks that a. The matching IG is a word-final IG (has a @ marker) b. The right-side topmost channel is empty (channel symbol nearest to ) is 0) c. The IG is not linked to any other in any of the lower channels d. No links in any of the lower channels cross into this segment (that is, there are no 1s in lower channels.) These conditions imply that the only channel symbol that may appear in the right side of a dependent IG is 0.</Paragraph> <Paragraph position="9"> 2. The regular expression ML = [&quot;<&quot; LeftChannelSymbols* &quot;0&quot; &quot;(&quot; ] ensures that the topmost channel is empty, but it does not constrain the symbols in the lower channels, if any, as there may be other links ending at the matching IG.</Paragraph> <Paragraph position="10"> 3. Similarly, the regular expression</Paragraph> <Paragraph position="12"> the topmost channel is empty. Note that since the matching IG is the IG of the head, multiple dependency links may end at the matching IG, so there are no constraints on the symbols in the lower channels, but there cannot be any 1s on the left side, since that would imply a lower link crossing to the right side.</Paragraph> <Paragraph position="13"> For instance, the rule and it matches any nominal IG (including any derived nominals) with nominative case and +A3pl agreement. There are a number of points to note in this expression: 1. (...) indicates optionality: The RootWord, a regular expression matching a sequence of one or more characters in the Turkish alphabet, is optional, since this may be a derived noun for which the root would be in a previous IG.</Paragraph> <Paragraph position="14"> 2. NominalType, another optional component, is a regular expression matching possible minor part-of-speech tags for nouns and pronouns. 3. PossessiveAgreement is a regular expression that matches all possible possessive agreement markers.</Paragraph> <Paragraph position="15"> 4. The nominal has third-person plural agreement and nominative case. The order of the components of this regular expression corresponds to the order of the morphological feature symbols produced by the morphological analyzer for a nominal IG. The regular expression FiniteVerbA3sgA3pl matches any finite-verb IG with either +A3sg or +A3pl number-person agreement. The regular expression AnyIG matches any IG.</Paragraph> <Paragraph position="16"> All the rules in the dependency grammar written in the form described are grouped together into a parallel bracketing regular expression defined as follows: Computational Linguistics Volume 29, Number 4 where left-hand-side patterns and dependent and head IGs are specified in accordance with the rule format given earlier. {Rel</Paragraph> <Paragraph position="18"> } are pairs of braces; there is a distinct pair for each syntactic relation to be identified by these rules (and not necessarily a unique one for each rule). This set of rules will produce all possible bracketings of the input IG sequence, subject to the constraints specified by the patterns. This overgeneration is then filtered (mostly at compile time and not at parse time) by a number of additional configurational and linguistic constraints that are discussed shortly.</Paragraph> </Section> <Section position="6" start_page="530" end_page="531" type="sub_section"> <SectionTitle> 6.4 Constructing the Parsing Transducer </SectionTitle> <Paragraph position="0"> In this section, we describe the components of the parsing transducer. As stated earlier, links are established in a number of iterations. Each iteration mainly consists of an application of a parsing transducer followed by a filtering transducer that eliminates certain redundant partial parse configurations.</Paragraph> <Paragraph position="1"> The parsing transducer consists of a transducer that inserts an empty channel followed by transducers that implement steps 2 to 4 described at the beginning of section 6.2.</Paragraph> <Paragraph position="2"> We can write the following regular expression for the parser transducer as The transducer AddChannel is a simple transducer that adds a pair of 0 channel symbols around the (...) in the IGs. It implements step 1 in section 6.2. The transducer Bracket was defined in the previous section. It implements step 2 described in section 6.2.</Paragraph> <Paragraph position="3"> Since the bracketing rules are nondeterministic, they will generate many configurations in which certain segments in the stacked channels will not be used. A rule may attempt to establish a link in the topmost channel even though the corresponding segment is not utilized in a previous channel (e.g., the corresponding segment of one of the previous channels may be all 0s). One needs to eliminate such redundant configurations after each iteration to prevent their proliferation at later iterations of the parser. Checking whether the segment just underneath the topmost channel is empty has worked perfectly in our experiments in that none of the parses selected had any empty segments that were not detected by this test. The regular expression FilterEmptySegments filters these configurations, an example of which is depicted in</Paragraph> </Section> <Section position="7" start_page="531" end_page="531" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> The transducer MarkChannels implements step 3 in section 6.2. This transducer modifies the channel symbols to mark a link: * The new (topmost) right channel symbol in the IG just to the right of the opening brace is modified to a link start symbol (one of the symbols s, o, m, p, c, d, t, l, f, i).</Paragraph> <Paragraph position="1"> * The new (topmost) right channel symbols on both sides of all the IGs fully bracketed by the braces (all IGs except the dependent and head IGs) are modified to 1; this is necessary so that that segment of the channel can be claimed and used for detecting crossing links.</Paragraph> <Paragraph position="2"> * The new (topmost) left channel symbol in the IG just to the left of the closing brace is modified to a link end symbol (one of the symbols S, O, M, P, C, D, T, L, F, I).</Paragraph> <Paragraph position="3"> Finally, the transducer RemoveBraces removes the braces.</Paragraph> <Paragraph position="4"> It should be noted that the transducer for Parse is computed off-line at compile time, so that no composition is done at parse time.</Paragraph> <Paragraph position="5"> The parsing scheme described above is bottom up, in that the links between closest head-dependent pairs are established first, in the lowest channel. Subsequent longer-distance links are established in later stages as long as they do not conflict with links established in lower channels. It is also conceivable that one could employ a top-down parsing scheme linking all pairs that are far apart, again checking for configurational constraints. If full nondeterminism is maintained in the bracketing step, it really does not matter whether one uses bottom-up or top-down parsing. Bottom-up parsing, however, offers certain advantages in that various (usually linguistically motivated) constraints that have to hold between nearby pairs or pairs that have to be immediately sequential can be enforced at an earlier stage by using simpler regular expressions. These constraints help prune the intermediate parse strings.</Paragraph> </Section> <Section position="8" start_page="531" end_page="533" type="sub_section"> <SectionTitle> 6.5 Dependency Structures with Both Left-to-Right and Right-to-Left Links </SectionTitle> <Paragraph position="0"> Although the formulation up until now has been one for dependency structures involving left-to-right dependency links, the approach presented above can handle a dependency grammar with both left-to-right and right-to-left links. In this section, we will outline the details of the changes that would be needed in such a formulation but will then go ahead with the left-to-right implementation, as that forms the basis of our implementation for Turkish, for which left-to-right links suffice for all practical purposes.</Paragraph> <Paragraph position="1"> Incorporating the right-to-left links into the approach would require the following modifications to the formulation: 1. The right-to-left links would use the same representation as the left-to-right links, except they would be distinguished by the symbols marking the links at the dependent and head IG sites. With the left-to-right links described so far, lowercase link symbols on the right side of an IG mark the dependent IG and uppercase symbols on the left 17 The details of the regular expressions for these transducers are rather uninteresting. They are essentially upper-side to lower-side contextual-replace regular expressions. For instance, RemoveBraces maps all brace symbols on the upper side to epsilon1 on the lower side.</Paragraph> <Paragraph position="2"> side of the IG mark the head IG (which follows the dependent IG in linear order). We would still use the same conventions for right-to-left links, except that we could have head and dependent IG markers on both sides of the channel representation. This is shown graphically in Figure 8. So a right-to-left link would have a lowercase link mark on the left side of the dependent IG and an uppercase link mark on the right side of the head IG to the left of the dependent IG.</Paragraph> <Paragraph position="3"> 2. With both left-to-right and right-to-left rules, we would need two different rule formats. The rule format for left-to-right links would be slightly different from the format given earlier: link, the direction would need to be indicated by the type of braces that are used to (temporarily) mark the segment claimed for the link. For instance, for a left-to-right rule to link a subject IG to a verb IG, we would use braces {SBJ-left-to-right and SBJ-left-to-right} and for a right-to-left rule (for the same kind of relation), we would use symbols {SBJ-right-to-left and SBJ-right-to-left}. The transducer that inserts the appropriate markers for links (MarkChannels in section 6.4) would then execute the appropriate action based on the type and the direction indication of the delimiting braces. For left-to-right braces it will insert the (lowercase) link start symbol to the right side of the left brace and the (uppercase) link end symbol to the left side of the right brace. For right-to-left braces, it will insert the link start symbol to the left side of the right brace and the link end symbol to the right side of the left brace.</Paragraph> <Paragraph position="4"> 4. The regular expressions checking the channel symbols around the dependent and head IGs would be different for the two types of rules.</Paragraph> <Paragraph position="5"> This is basically necessitated by the fact that since the IGs could now have links outgoing from both sides, checks have to be made on both sides:</Paragraph> <Paragraph position="7"> in left-to-right rules would check that the dependent IG is a word-final IG and is not already linked and that no links are</Paragraph> </Section> <Section position="9" start_page="533" end_page="534" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> crossing in or out. So it would function like LR, described in section 6.3.</Paragraph> <Paragraph position="1"> * LL, just to the left of the IGDep pattern, would also make sure that the IG is not linked, via a right-to-left link, to an IG further to the left.</Paragraph> <Paragraph position="3"> would function just like RL, described in section 6.3.</Paragraph> <Paragraph position="5"> , which, for right-to-left rules, would be constraining the left channel symbols of the head IG, would need only to ensure that the top channel is available for a link and that no other links are crossing in and out.</Paragraph> <Paragraph position="7"> would ensure that the dependent IG is not linked to any IG to the left and that there are no links crossing, and that the top channel is available.</Paragraph> <Paragraph position="8"> * RR, just to the right of IGDep in the right-to-left rule, would make sure that the dependent IG is not linked to any IG to the right and would additionally check that the top channel is available and that no links are crossing.</Paragraph> <Paragraph position="9"> There is, however, a potential problem for a grammar with both left-to-right and right-to-left links. Robinson's axioms (see section 3) do not seem to disallow cyclic dependency links (unless the antisymmetry is interpreted to apply over the transitive closure of the &quot;depends on&quot; relationship), but configurations involving cycles are not assumed to correspond to legitimate dependency structures.</Paragraph> <Paragraph position="10"> When both left-to-right and right-to-left links exists in a grammar, it is conceivable that two left-to-right rules may separately posit two left-to-right links, so that IG A links to IG B, IG B (or the word-final IG of the word to which B belongs) links to IG C, and later in a subsequent iteration, a right-to-left rule posits a link from IG C (or the word-final IG of the word to which C belongs) to IG A, where IG A precedes IG B, which precedes IG C in linear order. An implementation for a grammar would have to recognize such circular structures and eliminate them. It is possible to filter some of these cyclic configurations using a finite-state filter, but some will have to be checked later by a non-finite-state procedure.</Paragraph> <Paragraph position="11"> If all but one of the links forming a cycle are established in the same channel (e.g., following the example above, the links from IG A to IG B and from IG B to IG C are established in the next-to-the-topmost channel), the cycle-forming link has to be established in the (current) topmost channel (that is, the right-to-left link from IG C to IG A has to be established there; otherwise the configuration will be filtered by the rule that says links have to established as the earliest possible channel). In order for a cycle to form in this case, IGs A, B, and C with have to be in sequential words, and the cycle-inducing link and the other links in the &quot;other&quot; direction will all be side by side. A set of simple regular expressions can recognize if a series of pairs of link start and link end symbols in one direction all appearing in the next-to-top channel (i.e., the second symbol to the left and right of ( and ), respectively, are surrounded by a link end-link start pair for the cycle-inducing link in the other direction) and kill any such configurations.</Paragraph> <Paragraph position="12"> If, however, cycles are induced by links appearing in more than two different channels, then there is no elegant way of recognizing these in the finite-state framework, and such cases would have to be checked through other means.</Paragraph> </Section> <Section position="10" start_page="534" end_page="535" type="sub_section"> <SectionTitle> Computational Linguistics Volume 29, Number 4 6.6 Iterative Application of the Parser </SectionTitle> <Paragraph position="0"> Full parsing consists of iterative applications of the Parser transducer until a fixed point is reached. It should be noted that in general, different dependency parses of a sentence may use different numbers of channels, so all these parses have to be collected during each iteration.</Paragraph> <Paragraph position="1"> Let Sentence be a transducer that represents the word sequence. The pseudocode for iterative applications of the parser is given as follows: # Map sentence to a transducer representing a lattice of IGs</Paragraph> <Paragraph position="3"> Leaving the details of the transducer SyntacticFilter, a filter that eliminates configurations violating various linguistically motivated constraints, to a later section, this pseudocode works as follows: First, the sentence coded in Sentence is composed with the MorphologicalAnalyzer, which performs full morphological analysis of the tokens in the sentence along with some very conservative local morphological disambiguation. The resulting transducer encodes the sentence as a lattice representing all relevant morphological ambiguities. It is also possible to disambiguate the sentence prior to parsing with a tagger and present the parser with a fully disambiguated sentence.</Paragraph> <Paragraph position="4"> During each iteration, M encodes as a transducer, the valid partial-dependency configurations. First X is computed by applying the Parse and SyntacticFilter transducers, in that order, to M. At this point, there may be some complete parses, that is, configurations that have all except one of their word-final IGs linked (e.g., a parse in which every IG is linked to the next IG would use only the first channel, and such a parse would be generated right after the first iteration.) The transducer X encoding the result of one iteration of parsing is filtered by OnlyOneUnlinked, defined as</Paragraph> <Paragraph position="6"> This would be read as &quot;It is not the case that there is more than one instance of word-final IGs whose right channel symbols do not contain any outgoing link marker.&quot; This filter lets only those configurations that have all their required links established, 18 Note that this constraint is for a grammmar with left-to-right links.</Paragraph> </Section> <Section position="11" start_page="535" end_page="535" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> that is, all word-final IGs, except one, are linked (only one word-final IG has all of its right channel symbols as 0s and 1s.) Any such parses in Partial are unioned with Parses (initially empty) and removed from X to give the M for the next iteration. Any configurations among the remaining ones (with no links in the most recently added channel, because of optionality in bracketing) are filtered, since these will violate the empty-channel constraint (see Figure 7(b)). This is achieved by means of composition, with the transducer TopChannelNotEmpty defined as follows:</Paragraph> <Paragraph position="2"> This filter would be read as &quot;It is not the case that all topmost channel symbols in a configuration are all 0s.&quot; Thus configurations in which all most recent channel symbols are 0 are filtered. If the lower language of M (denoted by M.l) becomes empty at this point (or we exceed the number of maximum number of iterations), the iteration exits, with Parses containing the relevant result configurations. MaxIterations is typically small. In the worst case, the number of iterations one would need would equal the number of word-final IGs, but in our experiments parsing has converged in five or six iterations, and we have used eight as the maximum.</Paragraph> </Section> <Section position="12" start_page="535" end_page="536" type="sub_section"> <SectionTitle> 6.7 Handling Coordinating Conjunctions </SectionTitle> <Paragraph position="0"> Headless constructions such as coordinating conjunctions have been one of the weaker points of dependency grammar approaches. Our implementation of coordinate conjunction constructs essentially follows the formulation of J&quot;arvinen and Tapanainen (1998). For a sequence of IGs like</Paragraph> <Paragraph position="2"> are the dependent IGs that are coordinated and C represents the conjunction IGs (for, (comma), and, and or), and H is the head IG, we effectively thread a &quot;long link&quot; (possibly spanning multiple channels) from D</Paragraph> <Paragraph position="4"> links to the following C with link L, and this C links</Paragraph> <Paragraph position="6"> with L. This is conceptually equivalent to the following: The &quot;logical&quot; link with label L from conjoined dependent X and Y to their head Z is implemented with three actual links of type L: X-and, and-Y, and Y-Z. If there are additional conjunctions and conjuncts, we continue to add (as required) one link of type L per word: Linking conjoined dependents (W and X and Y)toZ is implemented with links W-and, and-X, X-and, and-Y, and Y-Z.</Paragraph> <Paragraph position="7"> One feature of Turkish simplifies this threading a bit: The left conjunct IG has to immediately precede the conjunction IG. The rules that do not involve conjunctions establish the link between D k and H. For each such rule, we need two simple rules: The first rule links a dependent D</Paragraph> <Paragraph position="9"> ,(i < k), to the conjunction immediately following. Since the link type is almost always determined by the inflectional features of the dependent, this linking can be done (ambiguously in a very few cases in which dependent features do not uniquely determine the link type). The second rule links the conjunction to the right conjunct. Note that this applies only to conjunct IGs that have already been linked to from their left conjunct. Since the outermost link symbol on the left side of a conjunction IG identifies the relation (because the left conjunct is immediately to the left of this IG), the link emanating from the conjunction to the right can be made to land on an IG that agrees with the left conjunct in relevant features.</Paragraph> <Paragraph position="10"> all the way to H l are independently threaded. A number of additional constraints also filter situations in which a conjoined head has both conjoined and locally attached dependents of the same type, by checking that the left channel symbols for these are not interleaved with other symbols. Figure 9 provides an example for this kind of conjunction ambiguity. In this implementation we have not attempted to handle circumscribing conjunctions such as the equivalents of either ...or.</Paragraph> </Section> <Section position="13" start_page="536" end_page="537" type="sub_section"> <SectionTitle> 6.8 Enforcing Syntactic Constraints </SectionTitle> <Paragraph position="0"> The rules linking the IGs are overgenerating in that they may generate configurations that may violate some general or language-specific constraints. For instance, more than one subject or one object may attach to a verb, more than one determiner or possessor may attach to a nominal, an object may attach to a verb that is then passivized in the next IG, or a nominative personal pronoun may be linked as a direct object (which is not possible in Turkish).</Paragraph> <Paragraph position="1"> Some of the constraints preventing these configurations can be encoded in the bracketing rule patterns. For instance, a rule for linking a nominal IG to a verb IG as a subject may check, using a suitable regular expression, the left-hand channel symbols of the verb IG to make sure that it does not already contain an incoming subject link. There are also a number of situations in which the determination of a link depends on a pattern that is outside the sequence of the IGs from dependent to the head IG specified in a bracketing rule (but nevertheless in the same word in which the head IG is located). For instance, in Turkish, present participles are considered</Paragraph> </Section> <Section position="14" start_page="537" end_page="538" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> modifiers derived from verbs. The verb part is the head of the sentential clause with a subject gap. Thus if a nominal IG attaches to a verb IG as a subject, but the verb IG is followed by another IG indicating that it is a present participle, then we should kill this configuration, since such verbs are not allowed to have subjects. It is also possible to incorporate almost all lexicalized argument structure-related constraints for dealing with intransitive and transitive verbs, provided the lexicon component (the morphological analyzer in our case) produces such lexically determined features.</Paragraph> <Paragraph position="1"> We have chosen not to encode such constraints in the general format of the rules and to implement them instead as filters that eliminate configurations produced by the parsing. We have observed that this makes the linking rules more perspicuous and easier to maintain.</Paragraph> <Paragraph position="2"> Each constraint is implemented as a finite-state filter that operates on the outputs of the Parse transducer by checking the symbols denoting the relations. For instance, we can define the following regular expression for filtering out configurations in which two determiners are attached to the same IG:</Paragraph> <Paragraph position="4"> This regular expression constrains the form of the configurations generated by parsing.</Paragraph> <Paragraph position="5"> Note that this transducer lets through a sequence of zero or more IGs, none of which have more than one D symbol (indicating an incoming determiner link) among the left channel symbols. The crucial portion at the beginning of the regular expression says: &quot;For any IG, it is not the case that there is more than one substring containing D among the left channel symbols of that IG (that is, the intersection of the symbols between < and ( with LeftChannelSymbols does not contain more than one D).&quot; We can provide the following finite-state filter as an example in which the violating configurations can be found by checking IGs following the head IG. For instance, the configurations in which subjects are linked to verbs which are then derived into present participles would be filtered by a finite-state filter like which says that the configuration does not contain, among the left-side channel symbols, a verb IG with a subject marker followed by a present participle IG.</Paragraph> <Paragraph position="6"> The following are examples of the constraints that we have encoded as finite-state filters: In the current implementation we use a total of 28 such constraints.</Paragraph> </Section> <Section position="15" start_page="538" end_page="539" type="sub_section"> <SectionTitle> 6.9 Robust Parsing </SectionTitle> <Paragraph position="0"> It is possible that either because of grammar coverage, or because of ungrammatical input, a parse with only one unlinked word-final IG may not be found. In such cases, Parses in the pseudocode for parsing presented in section 6.6 would be empty.</Paragraph> <Paragraph position="1"> One might, however, opt to accept parses with k > 1 unlinked word-final IGs when there are no parses with < k unlinked word-final IGs (for some small k). This can be achieved by using Karttunen's lenient composition operator (Karttunen 1998). Lenient composition, notated as .O., is used with a generator-filter combination. When a generator transducer, G, is leniently composed with a filter transducer, F, the resulting transducer, G .O. F, has the following behavior when an input is applied: If any of the outputs of G in response to an input string satisfy the filter F, then G .O. F produces just these as output. Otherwise, G .O. F outputs what G outputs.</Paragraph> <Paragraph position="2"> Let Unlinked i denote a regular expression that accepts parse configurations with no more than i unlinked word-final IGs. For instance, for i = 2, this would be defined as follows:</Paragraph> <Paragraph position="4"> which rejects configurations having more than two word-final IGs whose right channel symbols contain only 0s and 1s (i.e., they do not link to some other IG as a dependent).</Paragraph> <Paragraph position="5"> We can augment the pseudocode given in section 6.6 as follows: if (Parses == { }) { PartialParses = M .O. Unlinked_1 .O. Unlinked_2 .O. Unlinked_3; } This will have the parser produce outputs with up to three unlinked word-final IGs when there are no outputs with a smaller number of unlinked word-final IGs. Thus, it is possible to recover some of the partial-dependency structures when a full-dependency structure is not available for some reason. The caveat would be, however, that since Unlinked 1 is a very strong constraint, any relaxation would increase the number of outputs substantially. We have used this approach quite productively during the development of the dependency linking rules to discover coverage gaps in our grammar. 19 In fact, the morphological analyzer produces, for each postposition, a marker denoting the case of the preceding nominal as a subcategorization feature. This is used in a semilexicalized fashion while linking nominals to their head postpositions.</Paragraph> </Section> <Section position="16" start_page="539" end_page="540" type="sub_section"> <SectionTitle> Oflazer Dependency Parsing </SectionTitle> <Paragraph position="0"> 7. Experiments with Dependency Parsing of Turkish Our implementation work has mainly consisted of developing and implementing the representation and finite-state techniques involved here, along with a nontrivial grammar component; we have not attempted to build a wide-coverage parser that is expected to work on an arbitrary test corpus. Although we have built the grammar component manually using a very small set of sentences, it is conceivable that future work on inducing (possibly statistical) dependency grammars will exploit dependency treebanks, which are slowly becoming available (HajiVc 1998; Oflazer et al.</Paragraph> <Paragraph position="1"> 2003).</Paragraph> <Paragraph position="2"> The grammar has two major components. The morphological analyzer is a full-coverage analyzer built using XRCE finite-state tools, slightly modified to generate outputs as a sequence of IGs for a sequence of words. When an input sentence (again represented as a transducer denoting a sequence of words) is composed with the morphological analyzer (see the pseudocode given in section 6.6), a transducer for the lattice representing all IGs for all morphological ambiguities (remaining after a light morphological disambiguation) is generated. The dependency relations are described by a set of about 60 rules much like the ones exemplified earlier. These rules were developed using a small set of 30 sentences. The rules were almost all nonlexical, establishing links of the types listed earlier. There is an additional set of 28 finite-state constraints that impose various syntactic and structural constraints. The resulting Parser transducer has 13,290 states and 186,270 transitions, and the SyntacticFilter transducer has 3,800 states and 134,491 transitions. The combined transducer for morphological analysis and (very limited) disambiguation has 100,103 states and 243,533 arcs.</Paragraph> <Paragraph position="3"> The dependency grammar and the finite-state dependency parser were tested on a set of 200 Turkish sentences, including the 30 that were used for developing and testing the grammar. These sentences had 4 to 43 words, with an average of about 18 words. Table 1 presents our results for parsing this set of 200 sentences. This table presents the minimum, the maximum, and the average of the number of words and IGs per sentence, the number of parser iterations and the number of parses generated.</Paragraph> <Paragraph position="4"> (The number of iterations includes the last iteration where no new links are added.) There were 22 sentences among the 200 that had quite a number of verbal adjuncts that function as modifiers. These freely attach to any verb IG, creating an analog of the PP attachment problem and giving rise to a very large number of parses. The last row in the table gives the minimum, maximum and the average number of parses when such sentences were not considered.</Paragraph> <Paragraph position="5"> To impose a ranking on the parses generated based on just structural properties of the dependency tree, we employed Lin's (1996) notion of structural complexity. We measured the total link length (TLL) in a dependency parse counting the IGs the links pass over in the linear representation and ordered the dependency parses based on the TLL of the dependency tree. We classified the sentences into six groups: 1. Sentences that had a single minimum TLL parse which was correct. There were a total of 39 sentences (19.5%) in this group.</Paragraph> <Paragraph position="6"> 2. Sentences that had more than one parse with the same minimum TLL and the correct parse was among these parses. There were 58 sentences (29.0%) in this group. Thus for a total of 97 (48.5%) sentences, the correct parse was found among the parses with the minimum TLL. In these cases the average number of parses with the minimum TLL was about 6 Computational Linguistics Volume 29, Number 4 (minimum 1 parse and maximum 38 parses with the same minimum TLL).</Paragraph> <Paragraph position="7"> 3. Sentences for which the correct parse was not among the minimum TLL parses but was among the next-largest TLL group. There were 29 (14.5%) sentences in this group.</Paragraph> <Paragraph position="8"> 4. Sentences for which the correct parse was not among the smallest and the next-smallest TLL groups, but among the next three smallest TLL groups. There were a total of 26 (13%) sentences in this group.</Paragraph> <Paragraph position="9"> 5. Sentences for which the parser generated parses, but the correct parse was not among the first five groups. There were 26 (13%) such sentences. For these, we did not check any further and assumed there were no correct parses.</Paragraph> <Paragraph position="10"> The parses that were generated usually used other (morphological) ambiguities of the lexical item to arrive at a parse.</Paragraph> </Section> </Section> <Section position="11" start_page="540" end_page="543" type="metho"> <SectionTitle> 6. Sentences for which no parses could be found, usually as a result of the lack of </SectionTitle> <Paragraph position="0"> coverage of the dependency grammar and the morphological analyzer. There were 22 (11%) sentences in this group.</Paragraph> <Paragraph position="1"> It seems that for quite a number of sentences (groups 1-3 in the list), a relatively small number of parses have to be processed further with any additional lexical and/or statistical constraints to extract the correct parse. Although to obtain the statistics in items 1-6, we had to extract the full set of parse strings from the transducer that encoded the parses compactly, one does not have to do this. The parses with the shortest link length can be found by treating the resulting parse lattice transducer as a directed acyclic graph and finding the path with the minimum number of 1 symbols on it from the start state node to the final state node using one of the standard shortest-path algorithms (e.g., Dijsktra's algorithm [Cormen, Leiserson, and Rivest 1990]). This is because paths from the start state to the final state are string encodings of the dependency trees. The 1 symbols in the representation add up to the total link length of the encoded dependency tree. Since the representation of the tree is quite convoluted, the 1s in a block of 1s in the string representation all belong to different links stacked on top of each other. Thus we &quot;count&quot; the length of the links in an &quot;interleaved&quot; fashion. On the other hand, Dijkstra's algorithm may not be very useful, since one may need to extract the k shortest paths to select from, perhaps, later, with moreinformed criteria than link length, such as lexical and statistical information. For this we may use an algorithm which finds the k shortest paths between a source and a sink node in a directed graph (e.g., Eppstein 1998).</Paragraph> <Paragraph position="2"> The complete parser, including about 60 linking rules and the 28 syntactic constraints, is defined using about 240 regular expressions coded using XRCE regular expression language. These regular expressions compile in about one minute on Pentium III 700 MHz (running Linux) into the Parser and SyntacticFilter transducers.</Paragraph> <Paragraph position="3"> The parser iterations are handled by a script interpreted by the XRCE finite state tool, xfst.</Paragraph> <Paragraph position="4"> Parsing takes about a second per sentence, including lookup in the morphological analyzer, which is performed with a composition. With manually completely morphologically disambiguated input, parsing is essentially instantaneous.</Paragraph> <Paragraph position="5"> versus <O0S(sOyle+Verb+Pos+Past+A3sg@)000>.</Paragraph> <Paragraph position="6"> Figure 10 presents the input and the output of the parser for a sample Turkish sentence: D&quot;unya Bankasi T&quot;urkiye Direkt&quot;or&quot;uh&quot;uk&quot;umetin izlediVgi ekonomik programin sonucunda &quot;onemli adimlarin atildiVgini s&quot;oyledi. (The World Bank Turkey director said that as a result of the economic program followed by the government, important steps were taken.) Figure 11 shows the output of the parser processed with a Perl script to provide a more human-readable presentation: disambiguated. For this set of sentences, there were about 7 parses per sentence. The average number of parses for these sentences when all their morphological ambiguities were considered was 15. When the two sentences with the highest number of parses were removed from this set, the corresponding numbers were 3 parses per sentence and 11 parses per sentence.</Paragraph> <Paragraph position="7"> Dependency tree for the second parse.</Paragraph> <Paragraph position="8"> 8. Discussion and Conclusions We have presented the architecture and implementation of a dependency parser using an extended finite state. Although the emphasis has been on the description of the approach, we have developed a dependency grammar for Turkish and have used it to experiment with a small sample of 200 Turkish sentences. We have also employed a scheme for ranking dependency parses using the total link length of the dependency trees, as originally suggested by Lin (1996), with quite promising results. It is possible to use algorithms for extracting k shortest paths to extract parses from the transducer, which compactly encodes all dependency parses, and further to rank a much smaller set of parses using lexical and statistical information whenever available.</Paragraph> <Paragraph position="9"> Another interesting point that we have noted, especially during the development of the grammar, is that the grammar rules do not have to pay any real attention to the sequence of the IGs that do not have anything to do with the current rule (with a very few exceptions in some special cases in which the rules have to check that links do not cross a &quot;barrier&quot;). This means that that the grammar of the IG sequence is really localized to the morphological analyzer and that for the most part the dependency grammar does not have to &quot;know&quot; about the sequencing of the IGs within a word. In addition to the reductionistic disambiguator that we have used just prior to parsing, we have implemented a number of heuristics to limit the number of potentially spurious configurations that result from optionality in bracketing, mainly by enforcing obligatory bracketing for sequential dependent-head pairs (e.g., the complement of a postposition is immediately before it, or for conjunctions, the left conjunct is always the previous IG). Such heuristics force such dependencies to appear in the first channel and hence prune many potentially useless configurations popping up in later iterations. Although we have not performed any significant experiments with the robust parsing technique that we describe in the article, it has been very instrumental during the process of debugging the grammar. During debugging, when the actual parser did not deliver any results after a certain number of iterations, we generated partial parses with up to four unlinked word-final IGs to see where we were having problems with the coverage and added new linking rules.</Paragraph> <Paragraph position="10"> Research). A portion of this work was done while the author was visiting the Computing Research Laboratory at New Mexico State University. The author thanks Lauri Karttunen of Xerox PARC for making available XRCE finite-state tools. Mercan Karahan, currently of Purdue University, helped substantially with the implementation of the parser and with the experimentation. Comments by anonymous reviewers helped substantially to improve the article.</Paragraph> </Section> class="xml-element"></Paper>