<?xml version="1.0" standalone="yes"?>
<Paper uid="P98-2130">
  <Title>Formal aspects and parsing issues of dependency theory</Title>
  <Section position="2" start_page="0" end_page="788" type="intro">
    <SectionTitle>
1. Introduction
</SectionTitle>
    <Paragraph position="0"> Many authors have developed dependency theories that cover cross-linguistically the most significant phenomena of natural language syntax: the approaches range from generative formalisms (Sgall et al. 1986), to lexically-based descriptions (Mel'cuk 1988), to hierarchical organizations of linguistic knowledge (Hudson 1990) (Fraser, Hudson 1992), to constrained categorial grammars (Milward 1994). Also, a number of parsers have been developed for some dependency frameworks (Covington 1990) (Kwon, Yoon 1991) (Sleator, Temperley 1993) (Hahn et al. 1994) (Lombardo, Lesmo 1996), including a stochastic treatment (Eisner 1996) and an object-oriented parallel parsing method (Neuhaus, Hahn 1996).</Paragraph>
    <Paragraph position="1"> However, dependency theories have never been explicitly linked to formal models. Parsers and applications usually refer to grammars built around a core of dependency concepts, but there is a great variety in the description of syntactic constraints, from rules that are very similar to CFG productions (Gaifman 1965) to individual binary relations on words or syntactic categories (Covington 1990)  John likes beans&amp;quot;. The leftward or rightward orientation of the edges represents the order constraints: the dependents that precede (respectively, follow) the head stand on its left (resp. right).</Paragraph>
    <Paragraph position="2"> The basic idea of dependency is that the syntactic structure of a sentence is described in terms of binary relations (dependency relations) on pairs of words, a head (parent), and a dependent (daughter), respectively; these relations usually form a tree, the dependency tree (fig. 1).</Paragraph>
    <Paragraph position="3"> The linguistic merits of dependency syntax have been widely debated (e.g. (Hudson 1990)).</Paragraph>
    <Paragraph position="4"> Dependency syntax is attractive because of the immediate mapping of dependency trees on the predicate-arguments structure and because of the treatment of free-word order constructs (Sgall et al. 1986) (Mercuk 1988). Desirable properties of lexicalized formalisms (Schabes 1990), like finite ambiguity and decidability of string acceptance, intuitively hold for dependency syntax.</Paragraph>
    <Paragraph position="5"> On the contrary, the formal studies on dependency theories are rare in the literature.</Paragraph>
    <Paragraph position="6"> Gaifman (1965) showed that projective dependency grammars, expressed by dependency rules on syntactic categories, are weakly equivalent to context-free grammars. And, in fact, it is possible to devise O(n 3) parsers for this formalism (Lombardo, Lesmo 1996), or other projective variations (Milward 1994) (Eisner 1996). On the controlled relaxation of projective constraints, Nasr (1995) has introduced the condition of pseudodeg projectivity, which provides some controlled looser constraints on arc crossing in a dependency tree, and has developed a polynomial parser based on a graph-structured stack. Neuhaus and Broker (1997) have recently showed that the general recognition problem for non-projective dependency grammars (what they call discontinuous DG) is NP-complete.</Paragraph>
    <Paragraph position="7"> They have devised a discontinuous DG with exclusively lexical categories (no traces, as most dependency theories do), and dealing with free word order constructs through a looser subtree ordering. This formalism, considered as the most straightforward extension to a projective formalism, permits the reduction of the vertex cover problem to the dependency recognition problem, thus yielding the NP-completeness result. However, even if banned from the dependency literature, the use of non lexical categories is only a notational variant of some graph structures already present in some formalisms (see, e.g., Word Grammar (Hudson 1990)). This paper introduces a lexicalized dependency formalism, which deals  with long distance dependencies, and a polynomial parsing algorithm. The formalism is projective, and copes with long-distance dependency phenomena through the introduction of non lexical categories. The non lexical categories allow us to keep inalterate the condition of projectivity, encoded in the notion of derivation. The core of the grammar relies on predicate-argument structures associated with lexical items, where the head is a word and dependents are categories linked by edges labelled with dependency relations. Free word order constructs are dealt with by constraining displacements via a set data structure in the derivation relation. The introduction of non lexical categories also permits the resolution of the inconsistencies pointed out by Neuhaus and Broker in Word Grammar (1997).</Paragraph>
    <Paragraph position="8"> The parser is an Earley type parser with a polynomial complexity, that encodes the dependency trees associated with a sentence.</Paragraph>
    <Paragraph position="9"> The paper is organized as follows. The next section presents a formal dependency system that describes the linguistic knowledge. Section 3 presents an Earley-type parser: we illustrate the algorithm, trace an example, and discuss the complexity results. Section 4 concludes the paper. 2. A dependency formalism The basic idea of dependency is that the syntactic structure of a sentence is described in terms of binary relations (dependency relations) on pairs of words, a head (or parent), and a dependent (daughter), respectively; these relations form a tree, the dependency tree. In this section we introduce a formal dependency system. The formalism is expressed via dependency rules which describe one level of a dependency tree. Then, we introduce a notion of derivation that allows us to define the language generated by a dependency grammar of this form.</Paragraph>
    <Paragraph position="10"> The grammar and the lexicon coincide, since the rules are lexicalized: the head of the rule is a word of a certain category, i.e. the lexical anchor. From the linguistic point of view we can recognize two types of dependency rules: primitive dependency rules, which represent subcategorization frames, and non-primitive dependency rules, which result from the application of lexical metarules to primitive and non-primitive dependency rules.</Paragraph>
    <Paragraph position="11"> Lexical metarules (not dealt with in this paper) obey general principles of linguistic theories.</Paragraph>
    <Paragraph position="12"> A dependency grammar is a six-tuple &lt;W, C, S, D, I, H&gt;, where W is a finite set of symbols (words of a natural language); C is a set of syntactic categories (among which the special category E); S is a non-empty set of root categories (C ~ S); D is the set of dependency relations, e.g. SUB J, OBJ, XCOMP, P-OBJ, PRED (among which the special relation VISITOR1); I is a finite set of symbols (among which the special symbol 0), called u-indices; H is a set of dependency rules of the form</Paragraph>
    <Paragraph position="14"> 1) xe W, is the head of the rule; 2) Xe C, is its syntactic category; 3) an element &lt;r i Yi ui xj&gt; is a d-quadruple (which describbs a-de-pefident); the sequence of d-quads, including the symbol # (representing the linear position of the head, # is a special symbol), is called the d-quad sequence. We have that 3a) rieD, j e {1 ..... i-l, i+l ..... m}; 3b) Yje C,j e {1 ..... i-l, i+l ..... m}; 3c)ujeI, j e {1 ..... i-l, i+l ..... m}; 3d) x\]is a (possibly empty) set of triples &lt;u,  r, Y&gt;, called u-triples, where ue I, re D, YeC.</Paragraph>
    <Paragraph position="15"> Finally, it holds that: I) For each ue I that appears in a u-triple &lt;u, r, Y&gt;~Uj, there exists exactly one d-quad &lt;riYiu:\]xi&gt; in the same rule such that u=ui, i ~j. II) For each u=ui of a d-quad &lt;riYiuixi&gt;, there exists exactly one u-triple &lt;u, r, Y&gt;e x j, i~j, in the same rule.</Paragraph>
    <Paragraph position="16"> Intuitively, a dependency rule constrains one node (head) and its dependents in a dependency tree: the d-quad sequence states the order of elements, both the head (# position) and the dependents (d-quads). The grammar is lexicalized, because each dependency rule has a lexical anchor in its head (x:X). A d-quad &lt;rjYjujxj&gt; identifies a dependent of category Yi, co-rm-ect6d with the head via a dependency relation r i. Each element of the d-quad sequence is possibly fissociated with a u-index (uj) and a set of u-triples (x j). Both uj and xjcan be mill elements, i.e. 0 and ~, respectively. A u-triple (xcomponent of the d-quad) &lt;u, R, Y&gt; bounds the area of the dependency tree where the trace can be located. Given the constraints I and II, there is a one-to-one correspondence between the u-indices and the u-triples of the d-quads. Given that a dependency rule constrains one head and its direct dependents in the dependency tree, we have that the dependent indexed by uk is coindexed with a The relation VISITOR (Hudson 1990) accounts for displaced elements and, differently from the other relations, is not semantically interpreted.</Paragraph>
    <Paragraph position="17">  trace node in the subtree rooted by the dependent containing the u-triple &lt;Uk, R, Y&gt;.</Paragraph>
    <Paragraph position="18"> Now we introduce a notion of derivation for this formalism. As one dependency rule can be used more than once in a derivation process, it is necessary to replace the u-indices with unique symbols (progressive integers) before the actual use. The replacement must be consistent in the u and the x components. When all the indices in the rule are replaced, we say that the dependency rule (as well as the u-triple) is instantiated.</Paragraph>
    <Paragraph position="19"> A triple consisting of a word w (a W) or the trace symbol e(~W) and two integers g and v is a word object of the grammar.</Paragraph>
    <Paragraph position="20"> Given a grammar G, the set of word objects of G is Wx(G)={ ~tXv / IX, v_&gt;0, xe Wu {e} }.</Paragraph>
    <Paragraph position="21"> A pair consisting of a category X (e C) and a string of instantiated u-triples T is a category object of the grammar (X(T)).</Paragraph>
    <Paragraph position="22"> A 4-tuple consisting of a dependency relation r (e D), a category object X(yl), an integer k, a set of instantiated u-triples T2 is a derivation object of the grammar. Given a grammar G, the set of derivation</Paragraph>
    <Paragraph position="24"> Let a,~e Wx(G)* and Ve (Wx(G) u Cx(G) )*. The derivation relation holds as follows:  where x:X (&lt;rlYlUl'Cl&gt; ... &lt;ri-lYi-lUi-lZi-l&gt; # &lt;ri+lYi+lUi+l'~i+l&gt; ... &lt;rmY mUm'Cm &gt;) is a dependency rule, and Pl u ... u Pm--'q'p u Tx.  ct &lt;r,X( &lt;j,r,X&gt;),u,O&gt; =, a uej We define =~* as the reflexive, transitive closure of ~.</Paragraph>
    <Paragraph position="25"> Given a grammar G, L'(G) is the language of sequences of word objects: L'(G)={ae Wx(G)* / &lt;TOP, Q(i~), 0, 0&gt; :=&gt;* (x and Qe S(G)} where TOP is a dummy dependency relation. The language generated by the grammar G, L(G), is defined through the function t: L(G)={we Wx(G)* / w=t(ix) and oce L'(G)}, where t is defined recursively as</Paragraph>
    <Paragraph position="27"> where - is me empty sequence.</Paragraph>
    <Paragraph position="28"> As an example, consider the grammar</Paragraph>
    <Paragraph position="30"> where T(G1) includes the following dependency rules:  1. I: N (#); 2. John: N (#); 3. beans: N (#); 4. likes: V (&lt;SUBJ, N, 0, 0&gt;# &lt;OBJ, N, 0, 0)&gt;); 5. knOW: V+EX (&lt;VISITOR, N, ul, 0&gt;</Paragraph>
    <Paragraph position="32"> A derivation for the sentence &amp;quot;Beans I know John likes&amp;quot; is the following:  &lt;TOP, V+EX(O), 0, 0&gt; ::~ &lt;VISITOR, N(IEl), I, 0&gt; &lt;SUBJ, N(~), 0, 0&gt; know &lt;SCOMP, V(~), 0, {&lt;I,OBJ,N&gt;}&gt; :=~ lbeans &lt;SUBJ, N(O), 0, 0&gt; know &lt;SCOMP, V (O), 0, {&lt;I,OBJ,_N'&gt;}&gt; lbeans I know &lt;SCOMP, V(O), 0, {&lt;I,OBJ,N&gt;}&gt; =:~ lbeans I know &lt;SUBJ, N(O), 0, O&gt;likes &lt;OBJ, N(&lt;I,OBJ,N&gt;), 0, 0&gt; =:~ lbeans I know John likes &lt;OBJ, N(&lt;I,OBJ,N&gt;), 0, 0&gt; 1beans I know John likes el The dependency tree corresponding to this derivation is in fig. 2.</Paragraph>
  </Section>
class="xml-element"></Paper>