<?xml version="1.0" standalone="yes"?>
<Paper uid="W98-0511">
  <Title>Parsing with Dependency Relations and Robust Parsing</Title>
  <Section position="3" start_page="96" end_page="97" type="metho">
    <SectionTitle>
DANVAN
</SectionTitle>
    <Paragraph position="0"> and the dependency tree given above.</Paragraph>
    <Paragraph position="1"> Dependency relations must stipulate that a noun can appear on the left or on the fight below a verb and that below a noun, the determiner precedes the adjective. So we attach to each relation an vector of integers (either positive or negative) and we write:</Paragraph>
    <Paragraph position="3"> which says that we can have 0,1...n dependents of the DEP category below the governor of the GOV category.</Paragraph>
    <Paragraph position="4"> The integers are presented in ascending order, showing the relative position of DEP below GORY. For any given governor, the integer values also determine the relative positions of all its different possible dependents.</Paragraph>
    <Paragraph position="6"> Positive integers concern right dependents and negative integers left dependents. The integer of the second relation stipulate that the determiner, if any, will be placed before the adjectives, because -16 is less than -15 and -14. From the first relation we can see that no word can be placed, below the noun, between the two adjectives (there is no integer between - 15 and -14).</Paragraph>
    <Paragraph position="7"> These relations can be drawn as the following trees:</Paragraph>
    <Paragraph position="9"> An important thing to be noted is that each integer position gives the possibility for a dependent to be present at that position, but never imposes that presence.</Paragraph>
    <Paragraph position="10"> So the three relations above are equivalent to the following dependency grammar:</Paragraph>
    <Paragraph position="12"> It can be noted that these relations are in some sense similar to disjunctive forms of Sleator's link grammars (Sleator and Temperley 91).</Paragraph>
    <Section position="1" start_page="96" end_page="97" type="sub_section">
      <SectionTitle>
2.3. Parsing algorithm
</SectionTitle>
      <Paragraph position="0"> This algorithm supposes that the morphological step is finished and that it has produced the sequence of lexico-syntactic categories for the input sentence, each word corresponding to one category - or several if the word is ambiguous.</Paragraph>
      <Paragraph position="1"> So the parser's inputs are: * the sequence XI...Xn of categories computed by the morphological parser; * the set of dependency relations and the associated integer vectors.</Paragraph>
      <Paragraph position="2"> We add to the Xi sequence the pseudo category SI~'T=X0 which will help in determining the possible governor of the sentence (to initiate the parsing process). If, for example, possible main governors of a sentence are coordination conjunction (el and verb, we will have the relations:</Paragraph>
      <Paragraph position="4"> As we can have only one governor for a sentence, these two relations are mutually exclusive.</Paragraph>
      <Paragraph position="5"> This is expressed by the value of the integer: +1, which is the same for the two possible dependents of SENT.</Paragraph>
      <Paragraph position="6"> In order to build the dependency tree (or trees) associated with the given sequence of categories, the parser first initializes the square array of figure 1.</Paragraph>
      <Paragraph position="7"> As (Sleator And Temperley 91), we only want projective structures (or planar structures), i.e. trees which can be traversed by a left to right infix algorithm to find the original linear order of the sentence. The motivations for this limitation to projective structures are the following:  it is important to be able to retrieve, from the tree, the original linear form of the sentence; this limitation leads to greater parsing efficiency: for each governor, the search for its dependents will be made in two separate spaces: a left and a right space.</Paragraph>
      <Paragraph position="9"> Pij: set of integers determined by the relations</Paragraph>
      <Paragraph position="11"> Figure l : Square array fo r a sentence So for a given governor Xj, all its left dependents must have an index i &lt; j (the index order matches the word order in the sentence). The same is true for right dependents, with index k &gt; j. So we can remove from the top-right triangle of the array all positive numbers and from the bottom-left triangle all negative ones. We then have the two properties:  After having initialized the array and removed useless parts of it, the parser builds, with a descendant and recursive algorithm, all dependency structures compatible with the array: a) For each possible governor of the sentence (SENT column): b) build all left sub-trees and all right sub-trees (rocursively); c) build the final structures by merging the partial fight and left ones.</Paragraph>
      <Paragraph position="12"> One can say that we catch the SENT category and ,~ pull ~, the structures out of the array. The algorithm succeeds if at least one ~ pulled ~, structure contains all the words of the input sentence.</Paragraph>
      <Paragraph position="13"> With real sentences, of course, we have lexical ambiguities or structural ambiguities. In both cases, the algorithm is non-deterministic and builds all possible solutions by blind combinatorial enumeration.</Paragraph>
      <Paragraph position="14"> Dependency relations, associated with the algorithm described above, constitute a grammatical model with very few constraints. We can quickly state that the parser will succeed on more sentences than the language sentences. This feature can be viewed as an advantage in the framework of a man-machine communication system, where the essential quality of an utterance is to be interpretable, even if it is not syntactically correct: .Close file),, for example, is ungrammatical but we can interpret it and execute the associated command.</Paragraph>
      <Paragraph position="15"> On the contrary, this lack of constraints is penalizing efficiency: the algorithm will build a lot of incorrect structures because we can not state for example, that a given governor must have at least one dependent at that position, that a given relation only apply in a given context ....</Paragraph>
      <Paragraph position="16"> These limits and the necessary addition of some semantic knowledge in the syntactic parsing process lead us to design the new method for dependency tree construction presented in the second part.</Paragraph>
    </Section>
    <Section position="2" start_page="97" end_page="97" type="sub_section">
      <SectionTitle>
2.4. Conclusion
</SectionTitle>
      <Paragraph position="0"> Despite its relatively limited power of expression, this parser builds dependency structures extremely quickly (,&lt;instantaneously)&gt; on a personal computer) as long as the input sentence is not too long and not too ambiguous (say when the number of produced trees is less than 20).</Paragraph>
      <Paragraph position="1"> The parser has been put to use in a system for detection and correction of syntactic errors (Strube de Lima 90). The main purpose was to check the numerous concordancy rules for gender, number and person in written French sentences. For this type of application, it was of course essential for the parser not to take into account morphological properties of words while building dependency structures.</Paragraph>
      <Paragraph position="2"> By its lack of constraints and its high practical efficiency, this algorithm could be used in applications for man-machine interfaces where exchanges are short and language often approximative. null</Paragraph>
    </Section>
  </Section>
  <Section position="4" start_page="97" end_page="100" type="metho">
    <SectionTitle>
3. Robust Parsing
</SectionTitle>
    <Paragraph position="0"> The use of the preceding parser in a system for detection and correction of syntactic errors in French has raised the following problems: * even for a simple task such as detection and correction of agreement errors in written texts, you need a powerful parsing mechanism able to determine, for example, the antecedent of a relative pronoun; * a system for error correction can not rely on the correctness of the inputs in order to build a structure which is essential to make a minimal work. So you have to improve the knowledge of the system, i.e. in our case, to add some semantic information on words in order to determine more precisely the relations between them; * the syntactic parser of a such system must also be robust and produce an output even if the input is completely ill-formed.</Paragraph>
    <Paragraph position="1"> These problems lead us to define a new dependency parser which will be able to manipulate some semantic information and which will be error resistant. This work results in a prototype called CADET 2 of a dependency tree transducer, which we will describe in the following sections. 3.1. A language for writing dependency grammars We have attempted to design a language for the description of dependency structures retaining the precision of Tesni~re's grammars, but more appropriate for automatic treatment. Our basic idea is that the governor-dependent relation should not be expressed for two categories in general, but for two words which are instanciations of these categories in a given sentence. We therefore think it is necessary, when describing a governor-dependent relation, to indicate the context in which the relation is valid.</Paragraph>
    <Paragraph position="2"> To build dependency structures, we must be able to determine, for any two words, caracterized by their lexical category: determiner, noun, verb ..... which one governs the other. More generally, given two dependency trees, we must know how to merge them into a unique tree.</Paragraph>
    <Paragraph position="4"> We have defined a language based on rewriting rules; each rule applies to a dependency forest  and produces a dependency tree. A set of such rules constitutes a dependency grammar which can be applied to a sentence by means of an interpreter. This interpreter is in fact a treetransducer driven by the rules.</Paragraph>
    <Paragraph position="5"> Example of a simple rule: (the &amp;quot;-&amp;quot; begins</Paragraph>
    <Paragraph position="7"> This rule applies to any forest which includes a sequence of an N and a V, whose left dependents are only preverbal particles pv. It builds a new tree where the N is added as a dependent of the V.</Paragraph>
    <Paragraph position="8"> The advantage of these rules, compared to simple binary relations, is that it is possible to express the context of each category which appears. It is thus possible to restrict a governor to one or two dependents only, or to forbid more than one occurrence of a given category .... One can also define linked pairs of binary relations, as for coordination conjunctions (C):</Paragraph>
    <Paragraph position="10"> On the other hand, they present the drawback of the primitive dependency grammars: there must be a rule for almost every pair of lexical categories (LC). To avoid this problem, we have chosen to use a hierarchy of LCs instead of the usual linear set of LCs (Genthial &amp; al. 90). This hierarchy is a set, partially ordered by the is-a relation (figure 2).</Paragraph>
    <Paragraph position="11"> We can, in this manner, express very general rules like the two given above (NV and N_C) or more specific ones like: aux_~pas \[ (i: {xbe; xhave), 2: {pastp}) =&gt; ((1)2)\] By means ofis-a ((cnoun, pnoun}, N) and is-a ( {xbe, xhave, verb, pastp), V) relations, the N_V rule for instance may be applied to all the following pairs of categories: (cnoun, xbe) (pnoun, xbe) (cnoun, xhave) (pnoun, xhave) (cnoun, verb) (pnoun, verb) (cnoun, pastp) (pnoun, pastp) We can thus define a set of basic categories which describe words in a very specific way, and use these categories for lexical indexing. The categories can then be grouped in ,~ metacategories ~ according to the structures we want to build. Finally, we can write the rules which effectively build these structures.</Paragraph>
    <Paragraph position="12"> We can also write grammars in an incremental fashion, starting with the highest categories (e.g. N, V, A, C, P) then testing the rules on our corpus, progressively adding more precise rules for the lowest categories to treat specific phenomena. null So, by using this method, we can avoid the usual compromise between a very fine set of LCs (which multiplies morphological ambiguities and syntactic rules) and a very general set (which multiplies syntactic ambiguities). We also obtain a fairly robust syntactic parsing: all unknown words are given the most general category (CLS), to which any rule can apply, thus an unknown word does not stop the parsing process.</Paragraph>
    <Paragraph position="13"> Similar type hierarchies have already been used in work on language semantics to represent the taxonomy of semantic types. We shall therefore use the same formalism for the representation of syntactic and semantic knowledge (see SS3.3). N V A /on o cnoun ~xha~vVerb pastp adj We use the following abbreviations: cnoun and pnoun for common and proper nouns, xbe and xhave for the auxiliaries be and have, pastp for past participle, adj for adjective, P for preposition and C for coordination  Given a set of rewriting rules, the tree transducer proceeds by a left to right scanning of the input text. Each time a word is recognized by the morphological parser, it is transmitted to the syntactic module which includes it in the current state of the analysis. As the data manipulated by the tree transducer must be trees or forests, each word is transformed in a one node tree, where the root bears the information associated to the word.</Paragraph>
    <Paragraph position="14"> In order to manage multiple interpretations of the same word or of the same sentence, the transducer maintains a list of forests where each</Paragraph>
    <Paragraph position="16"> These forests, which are the current state of the analysis, are called stacks because each time a new word is recognized, a one node tree is I pushed on each forest and the parsing always _ _ resumes on the top of each forest.</Paragraph>
    <Paragraph position="17"> Given a list of stacks, the transducer applies each I applicable rule to the top of all stacks and each time a rule applies, a new stack is produced and added at the end of the list. Doing so, the transducer will also apply the rules to the new stacks I produced, cyclically. If more than one rule applies to a particular stack, more than one stack will be produced, but if at least one rule applies to a stack, this stack will be removed from the D I list.</Paragraph>
    <Paragraph position="18"> Example: (adapted from French) We consider only four categories: D,A, N, V (for I determiner, adjective, noun and verb) and we give the following very simple rules:</Paragraph>
    <Paragraph position="20"> n Figure 3 shows the evolution of the list of stacks during the parsing of the French nominal Figure 3: Stacks evolution phrase: ,~ la belle ferme ,, which is ambiguous and leads to the following sequence of catego- Our example gives three correct structures: I ties: - (la)belle(ferme) the firm beauty ((la)belle)ferme the beauty closes DIA~N~ (la,belle)ferme the beautiful farm I The algorithm is guaranted to stop because we &amp;l LV J We first introduce the word a la ,~ as a one node have added a constraint: rewriting rules are tree bearing the D category. As no rule can ap- written in such a way that the length of a stack must reduce each time a rule is applied to it. A i ply to this tree, we then introduce the word ,, belle ,, which is ambiguous. The ambiguity detailed discussion of termination and an gives two forests which are described on list (1). evaluation of the algorithm can be found in The D N rule applies to this list and gives list (2). (Genthial 91).</Paragraph>
    <Paragraph position="21"> N Introducing the word ferme leads to list 3.3. hierarchies (3), Type (( )) on which we detail rule application. So the rule We have chosen to represent knowledge about A_N applied to the second stack of the list pro- words and trees with a unique formalism: ~P- N duces a new forest (or stack) which is appended to the list. When the transducer ends with the terms (Ait-Kaci 84). ~P-terms are typed features original list, it finds the new produced stacks and structures which permit the description of types proceeds with them, applying grammar rules. (in the sense of classical programming lan- guages such as Pascal), i.e. sets of values. I The D_N rule will then be applied to the new produced forest (D, (A)N). The process stops Example: when the transducer reaches the end of the list UL(lex =&gt; &amp;quot;eats'; and, after removing the stacks where a rule has cat =&gt; verb; applied, we obtain list (4). subj =&gt; UL(sem =&gt; S:AN'DIA'I~) ; A correct interpretation (according to a given obj =&gt; UL(s~-'ta =&gt; O:EATABI~) ; grammar) of the input sentence can be found in sere =&gt; /2qGEST(agent =&gt; S; each stack which contains exactly one tree: this patient =&gt; O)) A tree is a dependency structure of the sentence.</Paragraph>
    <Paragraph position="22">  The use of reference tags like s or 0 allows structure sharing, so W-terms are not trees but graphs.</Paragraph>
    <Paragraph position="23"> Simple types are defined in the signature which is a set partially ordered by the is-a relation.</Paragraph>
    <Paragraph position="24"> This order is extended to W-terms by the unique operation used to manipulate them: unification.</Paragraph>
    <Paragraph position="25"> The unification of two simple types is defined as the set of lower bounds of these two types (in the is-a relation). Unification allows implicit inheritance of properties, and can be efficiently implemented (Ai't-Kaci &amp; al. 89).</Paragraph>
    <Paragraph position="26"> In our parser, a W-term is attached to each node of a tree and to transduction rules we have added expressions which enable us to test and modify those ~l'-terms. We can thus simultaneously build a syntactic structure (dependency tree) and a semantic structure (W-term, which also contains morphological and syntactical information), and which is built by unification (see also (Hellwig 86) on the use of unification for dependency parsing).</Paragraph>
    <Paragraph position="27"> Example of rules and application: We have two words:</Paragraph>
    <Section position="1" start_page="100" end_page="100" type="sub_section">
      <SectionTitle>
3.4. Conclusion
</SectionTitle>
      <Paragraph position="0"> The use of a category hierarchy simplifies the writing of the rules and introduces a way of manipulating unknown words which is not part of the mechanisms of the system but which is integrated in the objects it manipulates. We can then write rules without thinking about ill-formedness (i.e. it is not necessary to make the rules tolerant because the tolerance is implicit in the system).</Paragraph>
      <Paragraph position="1"> More generally, the use of unification in conjunction with dependency parsing allow to build syntactic structures efficiently while having the pFossibility to make very fine descriptions with -terms.</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>