Base_JSON/prefixJ/json/J11/J11-3004.json

{
    "paper_id": "J11-3004",
    "header": {
        "generated_with": "S2ORC 1.0.0",
        "date_generated": "2023-01-19T03:06:25.407441Z"
    },
    "title": "Dependency Parsing Schemata and Mildly Non-Projective Dependency Parsing",
    "authors": [
        {
            "first": "Carlos",
            "middle": [],
            "last": "G\u00f3mez-Rodr\u00edguez",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Sussex",
                "location": {
                    "postCode": "BN1 9QJ",
                    "settlement": "Falmer, Brighton",
                    "country": "UK"
                }
            },
            "email": ""
        },
        {
            "first": "John",
            "middle": [],
            "last": "Carroll",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Sussex",
                "location": {
                    "postCode": "BN1 9QJ",
                    "settlement": "Falmer, Brighton",
                    "country": "UK"
                }
            },
            "email": "j.a.carroll@sussex.ac.uk"
        },
        {
            "first": "David",
            "middle": [],
            "last": "Weir",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Sussex",
                "location": {
                    "postCode": "BN1 9QJ",
                    "settlement": "Falmer, Brighton",
                    "country": "UK"
                }
            },
            "email": "d.j.weir@sussex.ac.uk"
        }
    ],
    "year": "",
    "venue": null,
    "identifiers": {},
    "abstract": "We introduce dependency parsing schemata, a formal framework based on Sikkel's parsing schemata for constituency parsers, which can be used to describe, analyze, and compare dependency parsing algorithms. We use this framework to describe several well-known projective and non-projective dependency parsers, build correctness proofs, and establish formal relationships between them. We then use the framework to define new polynomial-time parsing algorithms for various mildly non-projective dependency formalisms, including well-nested structures with their gap degree bounded by a constant k in time O(n 5+2k), and a new class that includes all gap degree k structures present in several natural language treebanks (which we call mildly ill-nested structures for gap degree k) in time O(n 4+3k). Finally, we illustrate how the parsing schema framework can be applied to Link Grammar, a dependency-related formalism.",
    "pdf_parse": {
        "paper_id": "J11-3004",
        "_pdf_hash": "",
        "abstract": [
            {
                "text": "We introduce dependency parsing schemata, a formal framework based on Sikkel's parsing schemata for constituency parsers, which can be used to describe, analyze, and compare dependency parsing algorithms. We use this framework to describe several well-known projective and non-projective dependency parsers, build correctness proofs, and establish formal relationships between them. We then use the framework to define new polynomial-time parsing algorithms for various mildly non-projective dependency formalisms, including well-nested structures with their gap degree bounded by a constant k in time O(n 5+2k), and a new class that includes all gap degree k structures present in several natural language treebanks (which we call mildly ill-nested structures for gap degree k) in time O(n 4+3k). Finally, we illustrate how the parsing schema framework can be applied to Link Grammar, a dependency-related formalism.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Abstract",
                "sec_num": null
            }
        ],
        "body_text": [
            {
                "text": "Dependency parsing involves finding the structure of a sentence as expressed by a set of directed links (called dependencies) between individual words. Dependency formalisms have attracted considerable interest in recent years, having been successfully applied to tasks such as machine translation (Ding and Palmer 2005; Shen, Xu, and Weischedel 2008) , textual entailment recognition (Herrera, Pe\u00f1as, and Verdejo 2005) , relation extraction (Culotta and Sorensen 2004; Fundel, K\u00fcffner, and Zimmer 2006) , and question answering (Cui et al. 2005) . Key characteristics of the dependency parsing approach are that dependency structures specify head-modifier and head-complement relationships, which form the basis of predicate-argument structure, but are not represented explicitly in constituency trees; there is no need for dependency parsers to postulate the existence of non-lexical nodes; and some variants of dependency parsers are able to represent non-projective structures , which is important when parsing free word order languages where discontinuous constituents are common.",
                "cite_spans": [
                    {
                        "start": 298,
                        "end": 320,
                        "text": "(Ding and Palmer 2005;",
                        "ref_id": "BIBREF13"
                    },
                    {
                        "start": 321,
                        "end": 351,
                        "text": "Shen, Xu, and Weischedel 2008)",
                        "ref_id": "BIBREF58"
                    },
                    {
                        "start": 385,
                        "end": 419,
                        "text": "(Herrera, Pe\u00f1as, and Verdejo 2005)",
                        "ref_id": "BIBREF32"
                    },
                    {
                        "start": 442,
                        "end": 469,
                        "text": "(Culotta and Sorensen 2004;",
                        "ref_id": "BIBREF12"
                    },
                    {
                        "start": 470,
                        "end": 503,
                        "text": "Fundel, K\u00fcffner, and Zimmer 2006)",
                        "ref_id": "BIBREF20"
                    },
                    {
                        "start": 529,
                        "end": 546,
                        "text": "(Cui et al. 2005)",
                        "ref_id": "BIBREF11"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "The formalism of parsing schemata, introduced by Sikkel (1997) , is a useful tool for the study of constituency parsers, supporting precise, high-level descriptions of parsing algorithms. Potential applications of parsing schemata include devising correctness proofs, extending our understanding of relationships between different algorithms, deriving new variants of existing algorithms, and obtaining efficient implementations automatically (G\u00f3mez-Rodr\u00edguez, Vilares, and Alonso 2009) . The formalism was originally defined for context-free grammars (CFG) and since then has been applied to other constituency-based formalisms, such as tree-adjoining grammars (Alonso et al. 1999) . This article considers the application of parsing schemata to the task of dependency parsing. The contributions of this article are as follows.",
                "cite_spans": [
                    {
                        "start": 49,
                        "end": 62,
                        "text": "Sikkel (1997)",
                        "ref_id": "BIBREF61"
                    },
                    {
                        "start": 443,
                        "end": 486,
                        "text": "(G\u00f3mez-Rodr\u00edguez, Vilares, and Alonso 2009)",
                        "ref_id": "BIBREF25"
                    },
                    {
                        "start": 662,
                        "end": 682,
                        "text": "(Alonso et al. 1999)",
                        "ref_id": "BIBREF1"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "r We introduce dependency parsing schemata, a novel adaptation of the original parsing schemata framework (see Section 2).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "r We use the dependency parsing schemata to define and compare a number of existing dependency parsers (projective parsers are presented in Section 3, and their formal properties discussed in Sections 4 and 5; a number of non-projective parsers are presented in Section 6).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "r We present parsing algorithms for several sets of mildly non-projective dependency structures, including a parser for a new class of structures we call mildly ill-nested, which encompasses all the structures in a number of existing dependency treebanks (see Section 7).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "r We adapt the dependency parsing schema framework to the formalism of Link Grammar Temperley 1991, 1993 ) (see Section 8).",
                "cite_spans": [
                    {
                        "start": 84,
                        "end": 104,
                        "text": "Temperley 1991, 1993",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "Although some of these contributions have been published previously, this article presents them in a thorough and consistent way. The definition of dependency parsing schemata was first published by , along with some of the projective schemata presented here and their associated proofs. The results concerning mildly non-projective parsing in Section 7 were first published by Carroll (2008, 2009) . On the other hand, the material on Nivre and Covington's projective parsers, as well as all the non-projective parsers and the application of the formalism to Link Grammar, are entirely new contributions of this article.",
                "cite_spans": [
                    {
                        "start": 378,
                        "end": 398,
                        "text": "Carroll (2008, 2009)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "The notion of a parsing schema comes from considering parsing as a deduction process which generates intermediate results called items. In particular, items in parsing schemata are sets of partial constituency trees taken from the set of all partial parse trees that do not violate the constraints imposed by a grammar. A parsing schema can be used to obtain a working implementation of a parser by using deductive engines such as the ones described by Shieber et al. (1995) and G\u00f3mez-Rodr\u00edguez, Vilares, and Alonso (2009) , or the Dyna language (Eisner, Goldlust, and Smith 2005) .",
                "cite_spans": [
                    {
                        "start": 453,
                        "end": 474,
                        "text": "Shieber et al. (1995)",
                        "ref_id": "BIBREF59"
                    },
                    {
                        "start": 479,
                        "end": 522,
                        "text": "G\u00f3mez-Rodr\u00edguez, Vilares, and Alonso (2009)",
                        "ref_id": "BIBREF25"
                    },
                    {
                        "start": 546,
                        "end": 580,
                        "text": "(Eisner, Goldlust, and Smith 2005)",
                        "ref_id": "BIBREF17"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "Although parsing schemata were originally defined for CFG parsers, they have since been adapted to other constituency-based grammar formalisms. This involves finding a suitable definition of the set of structures contained in items, and a way to define deduction steps that captures the formalism's composition rules (Alonso et al. 1999) . Although it is less clear how to adapt parsing schemata to dependency parsing, a number of dependency parsers have the key property of being constructive: They proceed by combining smaller structures to form larger ones, terminating when a complete parse for the input sentence is found. We show that this makes it possible to define a variant of the traditional parsing schemata framework, where the encodings of intermediate dependency structures are defined as items, and the operations used to combine them are expressed as inference rules. We begin by addressing a number of preliminary issues.",
                "cite_spans": [
                    {
                        "start": 317,
                        "end": 337,
                        "text": "(Alonso et al. 1999)",
                        "ref_id": "BIBREF1"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependency Parsing Schemata",
                "sec_num": "2."
            },
            {
                "text": "Traditional parsing schemata are used to define grammar-driven parsers, in which the parsing process is guided by some set of rules which are used to license deduction steps. For example, an Earley PREDICTOR step is tied to a particular grammar rule, and can only be executed if such a rule exists. Some dependency parsers are also grammardriven. For example, those described by Lombardo and Lesmo (1996) , Barbero et al. (1998) , and Kahane, Nasr, and Rambow (1998) are based on the formalizations of dependency grammar CFG-like rules described by Hays (1964) and Gaifman (1965) . However, many of the algorithms (Eisner 1996; Yamada and Matsumoto 2003) are not traditionally considered to be grammar-driven, because they do not use an explicit formal grammar; decisions about which dependencies to create are taken individually, using probabilistic models (Eisner 1996) or classifiers (Yamada and Matsumoto 2003) . These are called data-driven parsers. To express such algorithms as deduction systems, we use the notion of D-rules (Covington 1990) . D-rules have the form (a, i) \u2192 (b, j), which specifies that a word b located at position j in the input string can have the word a in position i as a dependent. Deduction steps in data-driven parsers can be associated with the D-rules corresponding to the links they create, so that parsing schemata for such parsers are defined using grammars of D-rules. In this way, we obtain a representation of some of the declarative aspects of these parsing strategies that is independent of the particular model used to make the decisions associated with each D-rule. Note that this representation is useful for designing control structures or probabilistic models for the parsers, because it makes explicit the choice points where the models will have to make probabilistic decisions, as well as the information available at each of those choice points. Additionally, D-rules allow us to use an uniform description that is valid for both data-driven and grammar-driven parsers, because D-rules can function like grammatical rules.",
                "cite_spans": [
                    {
                        "start": 379,
                        "end": 404,
                        "text": "Lombardo and Lesmo (1996)",
                        "ref_id": "BIBREF41"
                    },
                    {
                        "start": 407,
                        "end": 428,
                        "text": "Barbero et al. (1998)",
                        "ref_id": "BIBREF2"
                    },
                    {
                        "start": 435,
                        "end": 466,
                        "text": "Kahane, Nasr, and Rambow (1998)",
                        "ref_id": "BIBREF35"
                    },
                    {
                        "start": 549,
                        "end": 560,
                        "text": "Hays (1964)",
                        "ref_id": "BIBREF31"
                    },
                    {
                        "start": 565,
                        "end": 579,
                        "text": "Gaifman (1965)",
                        "ref_id": "BIBREF21"
                    },
                    {
                        "start": 614,
                        "end": 627,
                        "text": "(Eisner 1996;",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 628,
                        "end": 654,
                        "text": "Yamada and Matsumoto 2003)",
                        "ref_id": "BIBREF66"
                    },
                    {
                        "start": 858,
                        "end": 871,
                        "text": "(Eisner 1996)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 887,
                        "end": 914,
                        "text": "(Yamada and Matsumoto 2003)",
                        "ref_id": "BIBREF66"
                    },
                    {
                        "start": 1033,
                        "end": 1049,
                        "text": "(Covington 1990)",
                        "ref_id": "BIBREF9"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependency Parsing Schemata",
                "sec_num": "2."
            },
            {
                "text": "The fundamental structures in dependency parsing are dependency trees. Therefore, just as items for constituency parsers encode sets of partial constituency trees, items for dependency parsers can be defined using partial dependency trees. However, dependency trees cannot express the fact that a particular structure has been predicted, but not yet built; this is required for grammar-based algorithms such as those of Lombardo and Lesmo (1996) and Kahane, Nasr, and Rambow (1998) . The formalism can be made general enough to include these parsers by using a novel way of representing intermediate states of dependency parsers based on a form of dependency trees that include nodes labelled with preterminals and terminals G\u00f3mez-Rodr\u00edguez 2009) . For simplicity of presentation, we will only use this representation (called extended dependency trees) in the grammar-based algorithms that need it, and we will define the formalism and the rest of the algorithms with simple dependency trees. Some existing dependency parsing algorithms, for example, the algorithm of Eisner (1996) , involve steps that connect spans which can represent disconnected dependency graphs. Such spans cannot be represented by a single dependency tree. Therefore, our formalism allows items to be sets of forests of partial dependency trees, rather than sets of trees.",
                "cite_spans": [
                    {
                        "start": 420,
                        "end": 445,
                        "text": "Lombardo and Lesmo (1996)",
                        "ref_id": "BIBREF41"
                    },
                    {
                        "start": 450,
                        "end": 481,
                        "text": "Kahane, Nasr, and Rambow (1998)",
                        "ref_id": "BIBREF35"
                    },
                    {
                        "start": 725,
                        "end": 746,
                        "text": "G\u00f3mez-Rodr\u00edguez 2009)",
                        "ref_id": "BIBREF22"
                    },
                    {
                        "start": 1068,
                        "end": 1081,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependency Parsing Schemata",
                "sec_num": "2."
            },
            {
                "text": "We are now ready to define the concepts needed to specify item sets for dependency parsers.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependency Parsing Schemata",
                "sec_num": "2."
            },
            {
                "text": "Definition 1 An interval (with endpoints i and j) is a set of natural numbers of the form [i..j] = {k | i \u2264 k \u2264 j}. We will use the notation i..j for the ordered list of the numbers in [i..j] . A dependency graph for a string w = w 1 . . . w n is a graph G = (",
                "cite_spans": [
                    {
                        "start": 185,
                        "end": 191,
                        "text": "[i..j]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependency Parsing Schemata",
                "sec_num": "2."
            },
            {
                "text": "V, E), where V \u2286 [1..n] and E \u2286 V \u00d7 V.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependency Parsing Schemata",
                "sec_num": "2."
            },
            {
                "text": "The edge (i, j) is written i \u2192 j, and each such edge is called a dependency link, encoding the fact that the word w i is a syntactic dependent (or child) of w j or, conversely, that w j is the parent, governor, or head of w i . We write i \u2192 j to denote that there exists a (possibly empty) path from i to j. The projection of a node i, denoted i , is the set of reflexive-transitive dependents of i, that is, i = {j \u2208 V | j \u2192 i}. In contexts where we refer to different dependency graphs, we use the notation i G to specify the projection of a node i in the graph G.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependency Parsing Schemata",
                "sec_num": "2."
            },
            {
                "text": "A dependency graph T for a string w 1 . . . w n is called a dependency tree for that string if it contains no cycles and all of its nodes have exactly one parent, except for one node that has none and is called the root or head of the tree T, denoted head (T) . The yield of a dependency tree T, denoted yield(T), is the ordered list of its nodes. We will use the term dependency forest to refer to a set of dependency trees for the same string, 1 and the generic term dependency structure to refer to a dependency tree or forest.",
                "cite_spans": [
                    {
                        "start": 256,
                        "end": 259,
                        "text": "(T)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2",
                "sec_num": null
            },
            {
                "text": "A dependency tree is said to be a parse tree for a string w 1 . . . w n if its yield is 1..n.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2",
                "sec_num": null
            },
            {
                "text": "We say that a dependency graph G = (V, E) for a string w 1 . . . w n is projective if i is an interval for every i \u2208 V.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3",
                "sec_num": null
            },
            {
                "text": "Let \u03b4(G) be the set of dependency trees which are syntactically well-formed according to a given grammar G (which may be a grammar of D-rules or of CFG-like rules, as explained previously). We define an item set for dependency parsing as a set I \u2286 \u03a0, where \u03a0 is a partition of the power set, (\u03b4(G)), of the set \u03b4(G). Each element of I, called an item, is a set of dependency forests for strings. For example, each member of the item [1, 5] in the item set of the parser by Yamada and Matsumoto (2003) that will be explained in Section 3.4 is a dependency forest with two projective trees, one with head 1 and the other with head 5, and such that the concatenation of their yields is 1..5. Figure 1 shows the three dependency forests that constitute the contents of this item under a specific grammar of D-rules.",
                "cite_spans": [
                    {
                        "start": 433,
                        "end": 436,
                        "text": "[1,",
                        "ref_id": null
                    },
                    {
                        "start": 437,
                        "end": 439,
                        "text": "5]",
                        "ref_id": null
                    },
                    {
                        "start": 473,
                        "end": 500,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 689,
                        "end": 697,
                        "text": "Figure 1",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Definition 4",
                "sec_num": null
            },
            {
                "text": "Following Sikkel (1997) , items are sets of syntactic structures and tuples are a shorthand notation for such sets, as seen in the previous example. An alternative approach,",
                "cite_spans": [
                    {
                        "start": 10,
                        "end": 23,
                        "text": "Sikkel (1997)",
                        "ref_id": "BIBREF61"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4",
                "sec_num": null
            },
            {
                "text": "Contents of the item [1, 5] from the Yamada and Matsumoto (2003) ",
                "cite_spans": [
                    {
                        "start": 21,
                        "end": 24,
                        "text": "[1,",
                        "ref_id": null
                    },
                    {
                        "start": 25,
                        "end": 27,
                        "text": "5]",
                        "ref_id": null
                    },
                    {
                        "start": 37,
                        "end": 64,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "parsing schema under a grammar of D-rules {(w 2 , 2) \u2192 (w 1 , 1) , (w 3 , 3) \u2192 (w 1 , 1) , (w 3 , 3) \u2192 (w 5 , 5) , (w 3 , 3) \u2192 (w 4 , 4) , (w 4 , 4) \u2192 (w 5 , 5)}.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "following Shieber, Schabes, and Pereira (1995) , would be to define items as tuples that denote sets of syntactic structures. Although the latter approach provides more flexibility, this makes defining the relationships between parsers less straightforward. In any case, because tuple notation is used to write schemata under both approaches, the schemata we provide are compatible with both interpretations.",
                "cite_spans": [
                    {
                        "start": 10,
                        "end": 46,
                        "text": "Shieber, Schabes, and Pereira (1995)",
                        "ref_id": "BIBREF59"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "Having defined an item set for dependency parsing, the remaining definitions are analogous to those in Sikkel's theory of constituency parsing (Sikkel 1997) , and are not presented in full detail. A dependency parsing system is a deduction system (I, H, D) where I is a dependency item set as defined here, H is a set containing initial items or hypotheses (not necessarily contained in I), and D \u2286 ( (H \u222a I ) \u00d7 I ) is a set of deduction steps defining an inference relation .",
                "cite_spans": [
                    {
                        "start": 143,
                        "end": 156,
                        "text": "(Sikkel 1997)",
                        "ref_id": "BIBREF61"
                    },
                    {
                        "start": 247,
                        "end": 256,
                        "text": "(I, H, D)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "Final items in this formalism will be those containing some forest F containing a parse tree for some string w 1 . . . w n . In parsers for general non-projective structures, any item containing such a tree will be called a coherent final item for w 1 . . . w n . In schemata for parsers that are constrained to a more restrictive class T of dependency trees, such as projective parsers, coherent final items will be those containing parse trees for w 1 . . . w n that are in T . For example, because we expect correct projective parsers to produce only projective structures, coherent final items for projective parsers will be those containing projective parse trees for w 1 . . . w n . Correctness proofs typically define a set of coherent items, such that its intersection with final items produces the set of coherent final items. The definition of coherent items depends on each particular proof. 2 For each input string, a parsing schema's deduction steps allow us to infer a set of items, called derivable items, for that string. 3 A parsing schema is said to be sound if all derivable final items it produces for any arbitrary string are coherent for that string. A parsing schema is said to be complete if all coherent final items are derivable. A correct parsing schema is one which is both sound and complete.",
                "cite_spans": [
                    {
                        "start": 903,
                        "end": 904,
                        "text": "2",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "Parsing schemata are located at a higher abstraction level than parsing algorithms, and formalize declarative aspects of their logic: A parsing schema specifies a set of intermediate results that are obtained by the algorithm (items) and a set of operations that can be used to obtain new such results from existing ones (deduction steps); but it makes no claim about the order in which to execute the operations or the data structures to use for storing the results.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "In this section, we show how dependency parsing schemata can be used to describe several existing projective dependency parsers.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Projective Schemata",
                "sec_num": "3."
            },
            {
                "text": "Representation of the [i, j, h] item in Collins's parser, together with one of the dependency structures contained in it (left side); and of the antecedents and consequents of an L-LINK step (right side). White rectangles in an item represent intervals of nodes that have been assigned a head by the parser, and dark squares represent nodes that have no head.",
                "cite_spans": [
                    {
                        "start": 22,
                        "end": 31,
                        "text": "[i, j, h]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 2",
                "sec_num": null
            },
            {
                "text": "One of the most straightforward projective dependency parsing strategies was introduced by Collins (1996) , and is based on the CYK bottom-up parsing strategy (Kasami 1965; Younger 1967 ). Collins's parser works with dependency trees which are linked to each other by creating links between their heads. The schema for this parser maps every set of D-rules G and input string w 1 . . . w n to an instantiated dependency parsing system (I Col96 , H, D Col96 ) such that:",
                "cite_spans": [
                    {
                        "start": 91,
                        "end": 105,
                        "text": "Collins (1996)",
                        "ref_id": "BIBREF6"
                    },
                    {
                        "start": 159,
                        "end": 172,
                        "text": "(Kasami 1965;",
                        "ref_id": "BIBREF36"
                    },
                    {
                        "start": 173,
                        "end": 185,
                        "text": "Younger 1967",
                        "ref_id": "BIBREF67"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Collins (1996)",
                "sec_num": "3.1"
            },
            {
                "text": "Item set: The item set is defined as I Col96 = {[i, j, h] | 1 \u2264 i \u2264 h \u2264 j \u2264 n}, where item [i, j, h]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Collins (1996)",
                "sec_num": "3.1"
            },
            {
                "text": "is defined as the set of forests containing a single projective dependency tree T of \u03b4(G) such that yield(T) is of the form i..j and head(T) = h (see Figure 2 , left side). From now on, we will implicitly assume that the dependency trees appearing in items of a parsing schema for a grammar G are taken from the set \u03b4(G) of syntactically well-formed trees according to G.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 150,
                        "end": 158,
                        "text": "Figure 2",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Collins (1996)",
                "sec_num": "3.1"
            },
            {
                "text": "This means that Collins's parser will be able to infer an item [i, j, h] in the presence of an input string w 1 . . . w n if, using our set of D-rules, it is possible to build a projective dependency tree headed at h that spans the substring w i . . . w j of the input.",
                "cite_spans": [
                    {
                        "start": 63,
                        "end": 72,
                        "text": "[i, j, h]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Collins (1996)",
                "sec_num": "3.1"
            },
            {
                "text": "Hypotheses: For an input string w 1 . . . w n , the set of hypotheses is",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Collins (1996)",
                "sec_num": "3.1"
            },
            {
                "text": "H = {[i, i, i] | 0 \u2264 i \u2264 n + 1},",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Collins (1996)",
                "sec_num": "3.1"
            },
            {
                "text": "where each item contains a forest with a single dependency tree having only one node i. This same set of hypotheses is used for all the parsers, so is not repeated for subsequent schemata. 4 Note that the nodes 0 and n + 1 used in the definition do not correspond to actual input words-these are dummy nodes that we call beginning-ofsentence and end-of-sentence markers, respectively, and will be needed by several of the parsers described subsequently.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Collins (1996)",
                "sec_num": "3.1"
            },
            {
                "text": "The set of final items is { [1, n, h] | 1 \u2264 h \u2264 n}. These items trivially represent parse trees for the input sentence whose head is some node h, expressing that the word w h is the sentence's syntactic head.",
                "cite_spans": [
                    {
                        "start": 28,
                        "end": 37,
                        "text": "[1, n, h]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Final items:",
                "sec_num": null
            },
            {
                "text": "The set of deduction steps, D Col96 , is the union of the following:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "R-LINK: [i, j, h 1 ] [ j + 1, k, h 2 ] [i, k, h 2 ] (w h 1 , h 1 ) \u2192 (w h 2 , h 2 ) L-LINK: [i, j, h 1 ] [ j + 1, k, h 2 ] [i, k, h 1 ] (w h 2 , h 2 ) \u2192 (w h 1 , h 1 )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "allowing us to join two contiguous trees by linking their heads with a rightward or leftward link, respectively. Figure 2 (right side) shows a graphical representation of how trees are joined by the L-LINK step. Note that, because this parsing strategy is data-driven, D-rules are used as side conditions for the parser's deduction steps. Side conditions restrict the inference relation by specifying which combinations of values are permissible for the variables appearing in the antecedents and consequent of deduction steps. This parsing schema specifies a recognizer: Given a set of D-rules and an input string w 1 . . . w n , the sentence can be parsed (projectively) under those D-rules if and only if the deduction system infers a coherent final item. When executing this schema with a deductive engine, the parse forest can be recovered by following back pointers, as in constituency parsers (Billot and Lang 1989) .",
                "cite_spans": [
                    {
                        "start": 900,
                        "end": 922,
                        "text": "(Billot and Lang 1989)",
                        "ref_id": "BIBREF3"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 113,
                        "end": 121,
                        "text": "Figure 2",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "This schema formalizes a parsing logic which is independent of the order and the way linking decisions are taken. Statistical models can be used to determine whether a step linking words a and b in positions i and j-i.e., having (a, i) \u2192 (b, j) as a side condition-is executed or not, and probabilities can be attached to items in order to assign different weights to different analyses of the sentence. The side conditions provide an explicit representation of the choice points where probabilistic decisions are made by the control mechanism that is executing the schema. The same principle applies to all D-rule-based parsers described in this article.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "Based on the number of free variables used in deduction steps of Collins's parser, it is apparent that its time complexity is O(n 5 ): There are O(n 5 ) combinations of index values with which each of its LINK steps can be executed. 5 This complexity arises because a parentless word (head) may appear in any position in the items generated by the parser; the complexity can be reduced to O(n 3 ) by ensuring that parentless words only appear at the first or last position of an item. This is the idea behind the parser defined by Eisner (1996) , which is still in wide use today (McDonald, Crammer, and Pereira 2005; Corston-Oliver et al. 2006) . The parsing schema for this algorithm is defined as follows.",
                "cite_spans": [
                    {
                        "start": 233,
                        "end": 234,
                        "text": "5",
                        "ref_id": null
                    },
                    {
                        "start": 531,
                        "end": 544,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 580,
                        "end": 617,
                        "text": "(McDonald, Crammer, and Pereira 2005;",
                        "ref_id": "BIBREF43"
                    },
                    {
                        "start": 618,
                        "end": 645,
                        "text": "Corston-Oliver et al. 2006)",
                        "ref_id": "BIBREF7"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "Item set: The item set is j, False, False] ",
                "cite_spans": [
                    {
                        "start": 26,
                        "end": 42,
                        "text": "j, False, False]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "I Eis96 = {[i, j, True, False] | 0 \u2264 i \u2264 j \u2264 n} \u222a {[i, j, False, True] | 0 \u2264 i \u2264 j \u2264 n} \u222a{[i,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "| 0 \u2264 i \u2264 j \u2264 n},",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "where item [i, j, True, False] and item [i, j, False, False] is defined as the set of forests of the form {T 1 , T 2 } such that T 1 , T 2 are projective, head(T 1 ) = i, head(T 2 ) = j, and there is some k (i \u2264 k < j) such that yield(T 1 ) = i..k and yield(T 2 ) = k + 1..j.",
                "cite_spans": [
                    {
                        "start": 11,
                        "end": 30,
                        "text": "[i, j, True, False]",
                        "ref_id": null
                    },
                    {
                        "start": 31,
                        "end": 60,
                        "text": "and item [i, j, False, False]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "corresponds to [i, j, j] \u2208 I Col96 , item [i, j, False, True] corre- sponds to item [i, j, i] \u2208 I Col96 ,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "The flags b, c in [i, j, b, c] indicate whether the nodes i and j, respectively, have a parent in the item. Items with one of the flags set to True represent dependency trees where the node i or j is the head, whereas items with both flags set to False represent pairs of trees headed at nodes i and j which jointly dominate the substring w i . . . w j . Items of this kind correspond to disconnected dependency graphs.",
                "cite_spans": [
                    {
                        "start": 18,
                        "end": 30,
                        "text": "[i, j, b, c]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "Deduction steps: The set of deduction steps is as follows: 6 INITTER:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "[i, i, i] [i + 1, i + 1, i + 1] [i, i + 1, False, False] COMBINESPANS: [i, j, b, c] [ j, k, not(c), d] [i, k, b, d] R-LINK: [i, j, False, False] [i, j, True, False] (w i , i) \u2192 (w j , j) L-LINK: [i, j, False, False] [i, j, False, True] (w j , j) \u2192 (w i , i)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "where the R-LINK and L-LINK steps establish a dependency link between the heads of an item containing two trees (i.e., having both flags set to False), producing a new item containing a single tree. The COMBINESPANS step is used to join two items that overlap at a single word, which must have a parent in only one of the items, so that the result of joining trees coming from both items (without creating any dependency link) is a well-formed dependency tree.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "Final items: The set of final items is {[0, n, False, True]}. Note that these items represent dependency trees rooted at the beginning-of-sentence marker 0, which acts as a \"dummy head\" for the sentence. In order for the algorithm to parse sentences correctly, we need to define D-rules to allow the real sentence head to be linked to the node 0.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner (1996)",
                "sec_num": "3.2"
            },
            {
                "text": "Eisner and Satta (1999) define an O(n 3 ) parser for split head automaton grammars which can be used for dependency parsing. This algorithm is conceptually simpler than Eisner's (1996) ",
                "cite_spans": [
                    {
                        "start": 11,
                        "end": 23,
                        "text": "Satta (1999)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 169,
                        "end": 184,
                        "text": "Eisner's (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner and Satta (1999)",
                "sec_num": "3.3"
            },
            {
                "text": "I ES99 = {[i, j, i] | 0 \u2264 i \u2264 j \u2264 n} \u222a {[i, j, j] | 0 \u2264 i \u2264 j \u2264 n},",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner and Satta (1999)",
                "sec_num": "3.3"
            },
            {
                "text": "where items are defined as in Collins's parsing schema.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner and Satta (1999)",
                "sec_num": "3.3"
            },
            {
                "text": "Deduction steps: The deduction steps for this parser are the following:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner and Satta (1999)",
                "sec_num": "3.3"
            },
            {
                "text": "R-LINK: [i, j, i] [ j + 1, k, k] [i, k, k] (w i , i) \u2192 (w k , k) L-LINK: [i, j, i] [ j + 1, k, k] [i, k, i] (w k , k) \u2192 (w i , i) R-COMBINER: [i, j, i] [ j, k, j] [i, k, i] L-COMBINER: [i, j, j] [ j, k, k] [i, k, k]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner and Satta (1999)",
                "sec_num": "3.3"
            },
            {
                "text": "where LINK steps create a dependency link between two dependency trees spanning adjacent segments of the input, and COMBINER steps join two overlapping trees by a graph union operation that does not create new links. COMBINER steps follow the same mechanism as those in the algorithm of Eisner (1996) , and LINK steps work analogously to those of Collins (1996) , so this schema can be seen as being intermediate between those two algorithms. These relationships will be formally described in Section 4.",
                "cite_spans": [
                    {
                        "start": 287,
                        "end": 300,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 347,
                        "end": 361,
                        "text": "Collins (1996)",
                        "ref_id": "BIBREF6"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner and Satta (1999)",
                "sec_num": "3.3"
            },
            {
                "text": "Final items: The set of final items is {[0, n, 0]}. By convention, parse trees have the beginning-of-sentence marker 0 as their head, as in the previous algorithm. When described for head automaton grammars (Eisner and Satta 1999) , this algorithm appears to be more complex to understand and implement than the previous one, requiring four different kinds of items to keep track of the state of the automata used by the grammars. However, this abstract representation of its underlying semantics reveals that this parsing strategy is, in fact, conceptually simpler for dependency parsing.",
                "cite_spans": [
                    {
                        "start": 207,
                        "end": 230,
                        "text": "(Eisner and Satta 1999)",
                        "ref_id": "BIBREF18"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Eisner and Satta (1999)",
                "sec_num": "3.3"
            },
            {
                "text": "Yamada and Matsumoto (2003) define a deterministic, shift-reduce dependency parser guided by support vector machines, which achieves over 90% dependency accuracy on Section 23 of the Wall Street Journal Penn Treebank. Parsing schemata cannot specify control strategies that guide deterministic parsers; schemata work at an abstraction level, defining a set of operations without procedural constraints on the order in which they are applied. However, deterministic parsers can be viewed as optimizations of underlying nondeterministic algorithms, and we can represent the actions of the underlying parser as deduction steps, abstracting away from the deterministic implementation details, obtaining a potentially interesting nondeterministic dependency parser.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Yamada and Matsumoto (2003)",
                "sec_num": "3.4"
            },
            {
                "text": "Actions in Yamada and Matsumoto's parser create links between two target nodes, which act as heads of neighboring dependency trees. One of the actions creates a link where the left target node becomes a child of the right one, and the head of a tree located directly to the left of the target nodes becomes the new left target node. The other action is symmetric, performing the same operation with a right-to-left link. An O(n 3 ) nondeterministic parser generalizing this behavior can be defined as follows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Yamada and Matsumoto (2003)",
                "sec_num": "3.4"
            },
            {
                "text": "Item set: The item set is",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Yamada and Matsumoto (2003)",
                "sec_num": "3.4"
            },
            {
                "text": "I YM03 = {[i, j] | 0 \u2264 i \u2264 j \u2264 n + 1}, where each item [i, j] corre- sponds to the item [i, j, False, False] in I Eis96 .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Yamada and Matsumoto (2003)",
                "sec_num": "3.4"
            },
            {
                "text": "Deduction steps: The deduction steps are as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Yamada and Matsumoto (2003)",
                "sec_num": "3.4"
            },
            {
                "text": "INITTER: [i, i, i] [i + 1, i + 1, i + 1] [i, i + 1] R-LINK: [i, j] [ j, k] [i, k] (w j , j) \u2192 (w k , k) L-LINK: [i, j] [ j, k] [i, k] (w j , j) \u2192 (w i , i)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Yamada and Matsumoto (2003)",
                "sec_num": "3.4"
            },
            {
                "text": "where a LINK step joins a pair of items containing forests with two trees each and overlapping at a head node, and creates a dependency link from their common head to one of the peripheral heads. Note that this is analogous to performing an Eisner LINK step immediately followed by an Eisner COMBINE step, as will be further analyzed in Section 4.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Yamada and Matsumoto (2003)",
                "sec_num": "3.4"
            },
            {
                "text": "Final items: The set of final items is {[0, n + 1]}. For this set to be well-defined, the grammar must not have D-rules of the form (w i , i) \u2192 (w n+1 , n + 1), that is, it must not allow the end-of-sentence marker to govern any words. If the grammar satisfies this condition, it is trivial to see that every forest in an item of the form [0, n + 1] must contain a parse tree rooted at the beginning-of-sentence marker and with yield 0..n. As can be seen from the schema, this algorithm requires less bookkeeping than the other parsers described here.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Yamada and Matsumoto (2003)",
                "sec_num": "3.4"
            },
            {
                "text": "The algorithms presented so far are based on making individual decisions about dependency links, represented by D-rules. Other parsers, such as that of Lombardo and Lesmo (1996) , use grammars with CFG-like rules which encode the preferred order of dependents for each given governor. For example, a rule of the form N(Det * PP) is used to allow N to have Det as left dependent and PP as right dependent. The algorithm by Lombardo and Lesmo is a version of Earley's CFG parser (Earley 1970 ) that uses Gaifman's dependency grammar (Gaifman 1965) .",
                "cite_spans": [
                    {
                        "start": 152,
                        "end": 177,
                        "text": "Lombardo and Lesmo (1996)",
                        "ref_id": "BIBREF41"
                    },
                    {
                        "start": 477,
                        "end": 489,
                        "text": "(Earley 1970",
                        "ref_id": "BIBREF15"
                    },
                    {
                        "start": 531,
                        "end": 545,
                        "text": "(Gaifman 1965)",
                        "ref_id": "BIBREF21"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lombardo and Lesmo (1996) and Other Earley-Based Parsers",
                "sec_num": "3.5"
            },
            {
                "text": "As this algorithm predicts dependency relations before building them, item sets contain extended dependency trees, trees that have two kinds of nodes: preterminal nodes and terminal nodes. Depending on whether all the preterminal nodes have been linked to terminals, extended dependency trees can either be grounded, in which case they are isomorphic to traditional dependency graphs (see Figure 3 ), or ungrounded, as in Figure 4 , in which case they capture parser states in which some structure has been predicted, but not yet found. Note that a dependency graph can always be extracted from such a tree, but in the ungrounded case different extended trees can be associated with the same graph. present extended dependency trees in more detail. Non-grounded extended dependency tree: A determiner and adjective have been found and, according to the grammar, we expect a noun that will act as their common head. As this head has not been read, no dependency links have been established.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 389,
                        "end": 397,
                        "text": "Figure 3",
                        "ref_id": "FIGREF0"
                    },
                    {
                        "start": 422,
                        "end": 430,
                        "text": "Figure 4",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Lombardo and Lesmo (1996) and Other Earley-Based Parsers",
                "sec_num": "3.5"
            },
            {
                "text": "= {[A(\u03b1 \u2022 \u03b2), i, j] | A(\u03b1\u03b2) \u2208 P \u2227 1 \u2264 i \u2264 j + 1 \u2264",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Item set: The item set is I LomLes",
                "sec_num": null
            },
            {
                "text": "[A(\u03b1 \u2022 \u03b2), i, j],",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Item set: The item set is I LomLes",
                "sec_num": null
            },
            {
                "text": "where \u03b2 is nonempty). Items in this parser can represent infinite sets of extended dependency trees, as in Earley's CFG parser but unlike items in D-rule-based parsers, which are finite sets.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Item set: The item set is I LomLes",
                "sec_num": null
            },
            {
                "text": "Deduction steps: The deduction steps for this parsing schema are as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Item set: The item set is I LomLes",
                "sec_num": null
            },
            {
                "text": "INITTER: [(\u2022S), 1, 0] * (S) \u2208 P PREDICTOR: [A(\u03b1 \u2022 B\u03b2), i, j] [B(\u2022\u03b3), j + 1, j] B(\u03b3) \u2208 P SCANNER: [A(\u03b1 \u2022 \u03b2), i, h \u2212 1] [h, h, h] [A(\u03b1 \u2022\u03b2), i, h] w h IS A COMPLETER: [A(\u03b1 \u2022 B\u03b2), i, j] [B(\u03b3\u2022), j + 1, k] [A(\u03b1B \u2022 \u03b2), i, k]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Item set: The item set is I LomLes",
                "sec_num": null
            },
            {
                "text": "Final items:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Item set: The item set is I LomLes",
                "sec_num": null
            },
            {
                "text": "The final item set is {[(S\u2022), 1, n]}.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Item set: The item set is I LomLes",
                "sec_num": null
            },
            {
                "text": "The schema for Lombardo and Lesmo's parser is a variant of the Earley constituency parser (cf. Sikkel 1997), with minor changes to adapt it to dependency grammar (for example, the SCANNER always moves the dot over the head symbol * , rather than over a terminal symbol). Analogously, other dependency parsing schemata based on CFG-like rules can be obtained by modifying CFG parsing schemata of Sikkel (1997) : The algorithm of Barbero et al. (1998) can be obtained from the left-corner parser, and the parser described by Courtin and Genthial (1998) is a variant of the head-corner parser.",
                "cite_spans": [
                    {
                        "start": 395,
                        "end": 408,
                        "text": "Sikkel (1997)",
                        "ref_id": "BIBREF61"
                    },
                    {
                        "start": 428,
                        "end": 449,
                        "text": "Barbero et al. (1998)",
                        "ref_id": "BIBREF2"
                    },
                    {
                        "start": 523,
                        "end": 550,
                        "text": "Courtin and Genthial (1998)",
                        "ref_id": "BIBREF8"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Item set: The item set is I LomLes",
                "sec_num": null
            },
            {
                "text": "Nivre (2003) describes a shift-reduce algorithm for projective dependency parsing, later extended by Nivre, Hall, and Nilsson (2004) . With linear-time performance and competitive parsing accuracy (Nivre et al. 2006; Nivre and McDonald 2008) , it is one of the parsers included in the MaltParser system (Nivre et al. 2007) , which is currently widely used (e.g., Nivre et al. 2007; Surdeanu et al. 2008) .",
                "cite_spans": [
                    {
                        "start": 101,
                        "end": 132,
                        "text": "Nivre, Hall, and Nilsson (2004)",
                        "ref_id": "BIBREF50"
                    },
                    {
                        "start": 197,
                        "end": 216,
                        "text": "(Nivre et al. 2006;",
                        "ref_id": "BIBREF52"
                    },
                    {
                        "start": 217,
                        "end": 241,
                        "text": "Nivre and McDonald 2008)",
                        "ref_id": "BIBREF53"
                    },
                    {
                        "start": 303,
                        "end": 322,
                        "text": "(Nivre et al. 2007)",
                        "ref_id": "BIBREF51"
                    },
                    {
                        "start": 363,
                        "end": 381,
                        "text": "Nivre et al. 2007;",
                        "ref_id": "BIBREF51"
                    },
                    {
                        "start": 382,
                        "end": 403,
                        "text": "Surdeanu et al. 2008)",
                        "ref_id": "BIBREF64"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "The parser proceeds by reading the sentence from left to right, using a stack and four different kinds of transitions between configurations. The transition system defined by all the possible configurations and transitions is nondeterministic, and machine learning techniques are used to train a mechanism that produces a deterministic parser.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "A deduction system describing the transitions of the parser is defined by Nivre, Hall, and Nilsson (2004) , with the following set of rules that describes transitions between configurations (we use the symbol \u03c1 for a stack and the notation \u03c1 :: h for the stack resulting from pushing h into \u03c1, and \u03b2 i to represent a buffer of the form w i . . . w n ):",
                "cite_spans": [
                    {
                        "start": 74,
                        "end": 105,
                        "text": "Nivre, Hall, and Nilsson (2004)",
                        "ref_id": "BIBREF50"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "Initter ( , \u03b2 0 , \u2205) Shift (\u03c1, \u03b2 f , V) (\u03c1 :: f, \u03b2 f +1 , V) Reduce (\u03c1 :: l, \u03b2 f , V) (\u03c1, \u03b2 f , V) \u2203a l \u2192 a k \u2208 V L-Link (\u03c1 :: l, \u03b2 f , V) (\u03c1 :: l :: f, \u03b2 f +1 , V \u222a {a f \u2192 a l }) a f \u2192 a l | a f \u2192 a k \u2208 V R-Link (\u03c1 :: l, \u03b2 f , V) (\u03c1, \u03b2 f , V \u222a {a l \u2192 a f }) a l \u2192 a f | a l \u2192 a k \u2208 V",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "This set of inference rules is not a parsing schema, however, because the entities it works with are not items. Although the antecedents and consequents in this deduction system are parser configurations, they do not correspond to disjoint sets of dependency structures (several configurations may correspond to the same dependency structures), and therefore do not conform to the definition of an item set. It would be possible to define parsing schemata in a different way with a weaker definition of item sets allowing these configurations as items, but this would make it harder to formalize relations between parsers, because they rely on the properties of item sets.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "A parsing schema for Nivre's parser can be obtained by abstracting away the rules in the system that are implementing control structures, however, and expressing only declarative aspects of the parser's tree building logic. To do this, we first obtain a simplified version of the deduction system. This version of the parser is obtained by storing an index f rather than the full buffer \u03b2 f in each configuration, and then grouping configurations that share common features, making them equivalent for the side conditions of the system: Instead of storing the full set of dependency links that the algorithm has constructed up to a given point (denoted by V), we only keep track of whether elements in the stack have been assigned a head or not; and we represent this by using a stack of pairs (l, b), where l is the position of a word in the string and b is a flag which is True if the corresponding node has been assigned a head or False if it has not:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "Initter ( , 0) Shift (\u03c1, f ) (\u03c1 :: ( f, False), f + 1) Reduce (\u03c1 :: (l, True), f ) (\u03c1, f ) L-Link (\u03c1 :: (l, h), f ) (\u03c1 :: (l, h) :: ( f, True), f + 1) (w f , f ) \u2192 (w l , l) R-Link (\u03c1 :: (l, False), f ) (\u03c1, f ) (w l , l) \u2192 (w f , f )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "To obtain a parsing schema from this deduction system, we retain only rules pertaining to the way in which the parser joins dependency structures and builds links between them. In particular, the Reduce step is just a mechanism to select which of a set of possible \"linkable words\" to link to the word currently being read. Two different configurations corresponding to the same dependency structure may have different lists of words in the stack depending on which Reduce steps have been executed. In the parsing schema, these configurations must correspond to the same item, as they involve the same dependency structures. To define an item set for this parser, we must establish which words could be on the stack at each configuration.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "A node in a dependency graph T is right-linkable if it is not a dependent of any node situated to its right, and is not covered by any dependency link ( j is covered by",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "the link i \u2192 k if i < j < k or i > j > k).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "A link cannot be created between a non-rightlinkable node and any node to the right of T without violating the projectivity property. When the parser is reading a particular word at position f , the following properties hold for all nodes to the left of f (nodes 0 . . . f \u2212 1):",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "r If the node i is not right-linkable, then it cannot be on the stack. r If the node i does not have a head, then it must be on the stack. (Note that nodes that do not have a head assigned are always right-linkable.)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "r If the node i has a head and it is right-linkable, then it may or may not be on the stack, depending on the transitions that we have executed.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "A dependency parsing schema represents items with lists (instead of stacks) containing all the nodes found so far which are right-linkable, and a flag associated with each node indicating whether it has been assigned a head or not. Instead of using Reduce steps to decide which node to choose as a head of the one corresponding to the currently-read word, we allow any node in the list that does not have a headless node to its right to be the head; this is equivalent to performing several Reduce transitions followed by an L-link transition.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "Item set: The item set is",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "I Niv = {[i, (i 1 , b 1 ), . . . , (i k , b k ) ] | 0 \u2264 i \u2264 n + 1 \u2227 0 \u2264 i 1 \u2264 . . . \u2264 i k \u2264 n \u2227 b j \u2208 {False, True}}",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "where an item [i, L] represents the set of forests of projective trees of the form F = {T 1 , . . . , T w } (w > 0) satisfying the following:",
                "cite_spans": [
                    {
                        "start": 14,
                        "end": 20,
                        "text": "[i, L]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "r The concatenation of the yields of T 1 , . . . , T w is 0..i, r",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "The heads of the trees T 1 , . . . , T w\u22121 are the nodes j where ( j, False) \u2208 L; and the head of the tree T w is the node i, r The right-linkable nodes in the dependency graph corresponding to the union of the trees in F are the nodes j where",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "( j, b) \u2208 L, with b \u2208 {False, True}. Final items: The set of final items is {[n + 1, (0, False), (v 1 , True), . . . , (v k , True) ] | 1 \u2264 v j \u2264",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "n}, the set of items containing a forest with a single projective dependency tree T headed at the dummy node 0, whose yield spans the whole input string, and which contains any set of right-linkable words.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "Deduction steps: The deduction steps are as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "INITTER: [0, ] ADVANCE: [i, (i 1 , b 1 ), . . . , (i k , b k ) ] [i + 1, (i 1 , b 1 ), . . . , (i k , b k ), (i, False) ] L-LINK: [i, (i 1 , b 1 ), . . . , (i k , b k ), (l, b), (v 1 , True), . . . , (v r , True) ] [i + 1, (i 1 , b 1 ), . . . , (i k , b k ), (l, b), (i, True) ] (w i , i) \u2192 (w l , l) R-LINK: [i, (i 1 , b 1 ), . . . , (i k , b k ), (h, False), (v 1 , True), . . . , (v r , True) ] [i, (i 1 , b 1 ), . . . , (i k , b k ) ] (w h , h) \u2192 (w i , i)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "Note that a naive nondeterministic implementation of this schema in a generic deductive engine would have exponential complexity. The linear complexity in Nivre's algorithm is achieved by using a control strategy that deterministically selects a single transition at each state.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Nivre (2003)",
                "sec_num": "3.6"
            },
            {
                "text": "Covington 2001defines a non-projective dependency parser, and a projective variant called Algorithm LSUP (for List-based Search with Uniqueness and Projectivity). Unfortunately, the algorithm presented in Covington 2001is not complete: It does not parse all projective dependency structures, because when creating leftward links it assumes that the head of a node i must be a reflexive-transitive head of the node i \u2212 1, which is not always the case. For instance, the structure shown in Figure 5 cannot be parsed because the constraints imposed by the algorithm prevent it from finding the head of 4.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 488,
                        "end": 496,
                        "text": "Figure 5",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Covington's (2001) Projective Parser",
                "sec_num": "3.7"
            },
            {
                "text": "The MaltParser system (Nivre et al. 2007) includes an implementation of a complete variant of Covington's LSUP parser where these constraints have been relaxed. This implementation has the same tree building logic as the parser described by Nivre (2003) , differing from it only with respect to the control structure. Thus, it can be seen as a different realization of the schema shown in Section 3.6.",
                "cite_spans": [
                    {
                        "start": 22,
                        "end": 41,
                        "text": "(Nivre et al. 2007)",
                        "ref_id": "BIBREF51"
                    },
                    {
                        "start": 241,
                        "end": 253,
                        "text": "Nivre (2003)",
                        "ref_id": "BIBREF48"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Covington's (2001) Projective Parser",
                "sec_num": "3.7"
            },
            {
                "text": "The parsing schemata framework can be exploited to establish how different algorithms are related, improving our understanding of the features of these parsers, and potentially exposing new algorithms that combine characteristics of existing parsers in novel ways. Sikkel (1994) defines various relations between schemata that fall into two categories: generalization relations, which are used to obtain more fine-grained versions of parsers, and filtering relations, which can be seen as the converse of generalization and are used to reduce the number of items and/or steps needed for parsing. Informally, a parsing schema can be generalized from another via the following transformations: r Item refinement: P 2 is an item refinement of P 1 , written P 1 ir \u2212 \u2192 P 2 , if there is a mapping between items in both parsers such that single items in P 1 are mapped into multiple items in P 2 and individual deductions are preserved.",
                "cite_spans": [
                    {
                        "start": 265,
                        "end": 278,
                        "text": "Sikkel (1994)",
                        "ref_id": "BIBREF60"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Relations Between Dependency Parsers",
                "sec_num": "4."
            },
            {
                "text": "r",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Relations Between Dependency Parsers",
                "sec_num": "4."
            },
            {
                "text": "Step refinement: P 1 sr \u2212 \u2192 P 2 if the item set of P 1 is a subset of that of P 2 and every deduction step in P 1 can be emulated by a sequence of steps in P 2 .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Relations Between Dependency Parsers",
                "sec_num": "4."
            },
            {
                "text": "A projective dependency structure that cannot be parsed with Covington's LSUP algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "A schema can be obtained from another by filtering in the following ways:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "r Static/dynamic filtering: P 1 sf /df \u2212 \u2212\u2212 \u2192 P 2",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "if the item set of P 2 is a subset of that of P 1 and P 2 allows a subset of the direct inferences in P 1 . Sikkel (1994) explains the distinction between static and dynamic filtering, which is not used here.",
                "cite_spans": [
                    {
                        "start": 108,
                        "end": 121,
                        "text": "Sikkel (1994)",
                        "ref_id": "BIBREF60"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "r Item contraction: The inverse of item refinement:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "P 1 ic \u2212 \u2192 P 2 if P 2 ir \u2212 \u2192 P 1 . r",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "Step contraction: The inverse of step refinement:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "P 1 sc \u2212 \u2192 P 2 if P 2 sr \u2212 \u2192 P 1 .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "Many of the parsing schemata described in Section 3 can be related (see Figure 6 ), but for space reasons we sketch proofs for only the more interesting cases.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 72,
                        "end": 80,
                        "text": "Figure 6",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "Theorem 1 Yamada and Matsumoto (2003) sr \u2212 \u2192 Eisner (1996) .",
                "cite_spans": [
                    {
                        "start": 10,
                        "end": 37,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    },
                    {
                        "start": 45,
                        "end": 58,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "It is easy to see from the schema definitions that I YM03 \u2286 I Eis96 . We must verify that every deduction step in the Yamada and Matsumoto (2003) schema can be emulated by a sequence of inferences in the Eisner (1996) schema. For the INITTER step this is trivial as the INITTERs of both parsers are equivalent. Expressing the R-LINK step of Yamada and Matsumoto's parser in the notation used for Eisner items gives:",
                "cite_spans": [
                    {
                        "start": 118,
                        "end": 145,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    },
                    {
                        "start": 204,
                        "end": 217,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 1",
                "sec_num": null
            },
            {
                "text": "R-Link [i, j, False, False] [j, k, False, False] [i, k, False, False] (w j , j) \u2192 (w k , k)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 1",
                "sec_num": null
            },
            {
                "text": "This can be emulated in Eisner's parser by an R-LINK step followed by a COMBINESPANS step:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 1",
                "sec_num": null
            },
            {
                "text": "[ j, k, False, False] [ j, k, True, False] (by R-LINK) [ j, k, True, False], [i, j, False, False] [i, k, False, False] (by COMBINESPANS)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 1",
                "sec_num": null
            },
            {
                "text": "Relating several well-known dependency parsers. Arrows pointing up correspond to generalization relations, while those pointing down correspond to filtering. The specific subtype of relation is shown in each arrow's label, following the notation in Section 4.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure",
                "sec_num": null
            },
            {
                "text": "Symmetrically, the L-LINK step in Yamada and Matsumoto's parser can be emulated by an L-LINK followed by a COMBINESPANS in Eisner's. Eisner and Satta (1999) sr \u2212 \u2192 Eisner (1996) .",
                "cite_spans": [
                    {
                        "start": 133,
                        "end": 156,
                        "text": "Eisner and Satta (1999)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 164,
                        "end": 177,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure",
                "sec_num": null
            },
            {
                "text": "Writing R-LINK in Eisner and Satta's parser in the notation used for Eisner items gives R-LINK:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "[i, j, False, True] [j + 1, k, True, False] [i, k, True, False] (w i , i) \u2192 (w k , k)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "This inference can be emulated in Eisner's parser as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "[ j, j + 1, False, False] (by INITTER) [i, j, False, True], [ j, j + 1, False, False] [i, j + 1, False, False] (by COMBINESPANS) [i, j + 1, False, False], [ j + 1, k, True, False] [i, k, False, False] (by COMBINESPANS) [i, k, False, False] [i, k, True, False] (by R-LINK)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "The proof corresponding to the L-LINK step is symmetric. As for the R-COMBINER and L-COMBINER steps in Eisner and Satta's parser, it is easy to see that they are particular cases of the COMBINESPANS step in Eisner's, and therefore can be emulated by a single application of COMBINESPANS.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "Note that, in practice, these two relations mean that the parsers by Eisner and Satta (1999) and Yamada and Matsumoto (2003) are more efficient, at the schema level, than that of Eisner (1996) , in that they generate fewer items and need fewer steps to perform the same deductions. These two parsers also have the interesting property that they use disjoint item sets (one uses items representing trees while the other uses items representing pairs of trees); and the union of these disjoint sets is the item set used by Eisner's parser. The optimization in Yamada and Matsumoto's parser comes from contracting deductions in Eisner's parser so that linking operations are immediately followed by combining operations; whereas Eisner and Satta's parser does the opposite, forcing combining operations to be followed by linking operations.",
                "cite_spans": [
                    {
                        "start": 69,
                        "end": 92,
                        "text": "Eisner and Satta (1999)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 97,
                        "end": 124,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    },
                    {
                        "start": 179,
                        "end": 192,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "By generalizing the linking steps in Eisner and Satta's parser so that the head of each item can be in any position, we obtain an O(n 5 ) parser which can be filtered into the parser of Collins (1996) by eliminating the COMBINER steps. From Collins's parser, we obtain an O(n 5 ) head-corner parser based on CFG-like rules by an item refinement in which each Collins item ",
                "cite_spans": [
                    {
                        "start": 186,
                        "end": 200,
                        "text": "Collins (1996)",
                        "ref_id": "BIBREF6"
                    },
                    {
                        "start": 359,
                        "end": 371,
                        "text": "Collins item",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "[i, j, h] is split into a set of items [A(\u03b1 \u2022 \u03b2 \u2022 \u03b3), i, j, h].",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "The refinement relation between these parsers only holds if for every D-rule B \u2192 A there is a corresponding CFG-like rule A \u2192 . . . B . . . in the grammar used by the head-corner parser. Although this parser uses three indices i, j, h, using CFG-like rules to guide linking decisions makes the h indices redundant. This simplification is an item contraction which results in an O(n 3 ) head-corner parser. From here, we can follow the procedure described by Sikkel (1994) to relate this head-corner algorithm to parsers analogous to other algorithms for CFGs. In this way, we can refine the head-corner parser to a variant of the algorithm by de Vreught and Honig (1989) (Sikkel 1997) , and by successive filters we reach a left-corner parser which is equivalent to the one described by Barbero et al. (1998) , and a step contraction of the Earley-based dependency parser by Lombardo and Lesmo (1996) . The proofs for these relations are the same as those given by Sikkel (1994) , except that the dependency variants of each algorithm are simpler (due to the absence of epsilon rules and the fact that the rules are lexicalized). The names used for schemata dVH1, dVH2, dVH3, and buLC shown in Figure 6 come from Sikkel (1994 Sikkel ( , 1997 . These dependency parsing schemata are versions of the homonymous schemata whose complete description can be found in Sikkel (1997) , adapted for dependency parsing. G\u00f3mez-Rodr\u00edguez (2009) gives a more thorough explanation of these relations and schemata.",
                "cite_spans": [
                    {
                        "start": 458,
                        "end": 471,
                        "text": "Sikkel (1994)",
                        "ref_id": "BIBREF60"
                    },
                    {
                        "start": 646,
                        "end": 670,
                        "text": "Vreught and Honig (1989)",
                        "ref_id": null
                    },
                    {
                        "start": 671,
                        "end": 684,
                        "text": "(Sikkel 1997)",
                        "ref_id": "BIBREF61"
                    },
                    {
                        "start": 787,
                        "end": 808,
                        "text": "Barbero et al. (1998)",
                        "ref_id": "BIBREF2"
                    },
                    {
                        "start": 875,
                        "end": 900,
                        "text": "Lombardo and Lesmo (1996)",
                        "ref_id": "BIBREF41"
                    },
                    {
                        "start": 965,
                        "end": 978,
                        "text": "Sikkel (1994)",
                        "ref_id": "BIBREF60"
                    },
                    {
                        "start": 1213,
                        "end": 1225,
                        "text": "Sikkel (1994",
                        "ref_id": "BIBREF60"
                    },
                    {
                        "start": 1226,
                        "end": 1241,
                        "text": "Sikkel ( , 1997",
                        "ref_id": "BIBREF61"
                    },
                    {
                        "start": 1361,
                        "end": 1374,
                        "text": "Sikkel (1997)",
                        "ref_id": "BIBREF61"
                    },
                    {
                        "start": 1409,
                        "end": 1431,
                        "text": "G\u00f3mez-Rodr\u00edguez (2009)",
                        "ref_id": "BIBREF22"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 1194,
                        "end": 1202,
                        "text": "Figure 6",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Proof 2",
                "sec_num": null
            },
            {
                "text": "Another use of the parsing schemata framework is that it is helpful in establishing the correctness of a parser. Furthermore, relations between schemata can be used to establish the correctness of one schema from that of related ones. In this section, we show that the schemata for Yamada and Matsumoto (2003) and Eisner and Satta (1999) are correct, and use this to prove the correctness of the schema for Eisner (1996) .",
                "cite_spans": [
                    {
                        "start": 282,
                        "end": 309,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    },
                    {
                        "start": 314,
                        "end": 337,
                        "text": "Eisner and Satta (1999)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 407,
                        "end": 420,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proving Correctness",
                "sec_num": "5."
            },
            {
                "text": "The Eisner and Satta (1999) parsing schema is correct.",
                "cite_spans": [
                    {
                        "start": 4,
                        "end": 27,
                        "text": "Eisner and Satta (1999)",
                        "ref_id": "BIBREF18"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 3",
                "sec_num": null
            },
            {
                "text": "To prove correctness, we must show both soundness and completeness. To verify soundness we need to check that every individual deduction step in the parser infers a coherent consequent item when applied to coherent antecedents (i.e., in this case, that steps always generate non-empty items that conform to the definition in Section 3.3). This is shown by checking that, given two antecedents of a deduction step that contain a tree licensed by a set of D-rules G, the consequent of the step also contains such a tree. The tree for the consequent is built from the trees corresponding to the antecedents: by a graph union operation, in the case of COMBINER steps; or by linking the heads of both trees with a dependency relation licensed by G, in the case of LINK steps.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 3",
                "sec_num": null
            },
            {
                "text": "To prove completeness we prove that all coherent final items are derivable by proving the stronger result that all coherent items are derivable. We show this by strong induction on the length of items, where the length of an item \u03b9 = [i, k, h] is defined as length(\u03b9) = k \u2212 i + 1. Coherent items of length 1 are the hypotheses of the schema (of the form [i, i, i]) which are trivially derivable. We show that, if all coherent items of length m are derivable for all 1 \u2264 m < l, then items of length l are also derivable.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 3",
                "sec_num": null
            },
            {
                "text": "Let [i, k, i] be an item of length l in I ES99 (thus, l = k \u2212 i + 1). If this item is coherent, it contains a dependency tree T such that yield(T) = i..k and head(t) = i. By construction, the root of T is labelled i. Let j be the rightmost daughter of i in T. Because T is projective, we know that the yield of j must be of the form l..k, where i < l \u2264 j \u2264 k. If l < j, then l is the leftmost transitive dependent of j in T, and if k > j, then we know that k is the rightmost transitive dependent of j in T.",
                "cite_spans": [
                    {
                        "start": 4,
                        "end": 13,
                        "text": "[i, k, i]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 3",
                "sec_num": null
            },
            {
                "text": "Let T j be the subtree of T rooted at j, T 1 be the tree obtained from removing T j by T, 8 T 2 be the tree obtained by removing all the nodes to the right of j from T j , and T 3 be the tree obtained by removing all the nodes to the left of j from T j . By construction, T 1 belongs to a coherent item [i, l \u2212 1, i], T 2 belongs to a coherent item [l, j, j] , and T 3 belongs to a coherent item [ j, k, j] . Because these three items have a length strictly less than l, by the inductive hypothesis, they are derivable. Thus the item [i, k, i] is also derivable, as it can be obtained from these derivable items by the following inferences:",
                "cite_spans": [
                    {
                        "start": 349,
                        "end": 358,
                        "text": "[l, j, j]",
                        "ref_id": null
                    },
                    {
                        "start": 396,
                        "end": 406,
                        "text": "[ j, k, j]",
                        "ref_id": null
                    },
                    {
                        "start": 534,
                        "end": 543,
                        "text": "[i, k, i]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 3",
                "sec_num": null
            },
            {
                "text": "[i, l \u2212 1, i], [l, j, j] [i, j, i] (by the L-LINK step) [i, j, i], [ j, k, j] [i, k, i] (bythe L-COMBINER step)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 3",
                "sec_num": null
            },
            {
                "text": "This proves that all coherent items of length l which are of the form [i, k, i] are derivable under the induction hypothesis. The same can be shown for items of the form [i, k, k] by symmetric reasoning.",
                "cite_spans": [
                    {
                        "start": 70,
                        "end": 79,
                        "text": "[i, k, i]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 3",
                "sec_num": null
            },
            {
                "text": "The Yamada and Matsumoto (2003) parsing schema is correct.",
                "cite_spans": [
                    {
                        "start": 4,
                        "end": 31,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 4",
                "sec_num": null
            },
            {
                "text": "Soundness is verified by building forests for the consequents of steps from those corresponding to the antecedents. To prove completeness we use strong induction on the length of items, where the length of an item [i, j] is defined as j \u2212 i + 1. The induction step involves considering any coherent item [i, k] of length l > 2 (l = 2 is the base case here because items of length 2 are generated by the Initter step) and showing that it can be inferred from derivable antecedents of length less than l, so it is derivable. If l > 2, either i has at least one right dependent or k has at least one left dependent in the item. Suppose i has a right dependent; if T 1 and T 2 are the trees rooted at i and k in a forest in [i, k], we call j the rightmost daughter of i and consider the following trees:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 4",
                "sec_num": null
            },
            {
                "text": "r V = the subtree of T 1 rooted at j, r U 1 = the tree obtained by removing V from T 1 , r U 2 = the tree obtained by removing all nodes to the right of j from V, r U 3 = the tree obtained by removing all nodes to the left of j from V.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 4",
                "sec_num": null
            },
            {
                "text": "The forest {U 1 , U 2 } belongs to the coherent item [i, j] , and {U 3 , T 2 } belongs to the coherent item [ j, k] . From these two items, we can obtain [i, k] by using the L-LINK step. Symmetric reasoning can be applied if i has no right dependents but k has at least one left dependent, analogously to the case of the previous parser.",
                "cite_spans": [
                    {
                        "start": 53,
                        "end": 59,
                        "text": "[i, j]",
                        "ref_id": null
                    },
                    {
                        "start": 108,
                        "end": 115,
                        "text": "[ j, k]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 4",
                "sec_num": null
            },
            {
                "text": "The Eisner (1996) parsing schema is correct.",
                "cite_spans": [
                    {
                        "start": 4,
                        "end": 17,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 5",
                "sec_num": null
            },
            {
                "text": "By using the previous proofs and the relationships between schemata established earlier, we show that the parser of Eisner (1996) is correct: Soundness is straightforward, and completeness can be shown by using the properties of other algorithms. Because the set of final items in the Eisner (1996) and Eisner and Satta (1999) schemata are the same, and the former is a step refinement of the latter, the completeness of Eisner and Satta's parser directly implies the completeness of Eisner's parser. Alternatively, we can use Yamada and Matsumoto's parser to prove the correctness of Eisner's parser if we redefine the set of final items in the latter to be items of the form [0, n + 1, False, False], which are equally valid as final items since they always contain parse trees. This idea can be applied to transfer proofs of completeness across any refinement relation.",
                "cite_spans": [
                    {
                        "start": 116,
                        "end": 129,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 285,
                        "end": 298,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 303,
                        "end": 326,
                        "text": "Eisner and Satta (1999)",
                        "ref_id": "BIBREF18"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 5",
                "sec_num": null
            },
            {
                "text": "The parsing schemata presented so far define parsers that are restricted to projective dependency structures, that is, structures in which the set of reflexive-transitive dependents of each node forms a contiguous substring of the input. We now show that the dependency parsing schema formalism can also describe various non-projective parsers.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Non-Projective Schemata",
                "sec_num": "6."
            },
            {
                "text": "Pseudo-projective parsers generate non-projective analyses in polynomial time by using a projective parsing strategy and postprocessing the results to establish non-projective links. This projective parsing strategy can be represented by dependency parsing schemata such as those seen in Section 3. For example, the algorithm of Kahane, Nasr, and Rambow (1998) uses a strategy similar to Lombardo and Lesmo (1996) , but with the following initializer step instead of the INITTER and PREDICTOR:",
                "cite_spans": [
                    {
                        "start": 329,
                        "end": 360,
                        "text": "Kahane, Nasr, and Rambow (1998)",
                        "ref_id": "BIBREF35"
                    },
                    {
                        "start": 388,
                        "end": 413,
                        "text": "Lombardo and Lesmo (1996)",
                        "ref_id": "BIBREF41"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Pseudo-Projectivity",
                "sec_num": "6.1"
            },
            {
                "text": "INITTER: [A(\u2022\u03b1), i, i \u2212 1] A(\u03b1) \u2208 P \u2227 1 \u2264 i \u2264 n",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Pseudo-Projectivity",
                "sec_num": "6.1"
            },
            {
                "text": "The initialization step specified by Kahane, Nasr, and Rambow (1998) differs from this (directly consuming a nonterminal from the input) but this gives an incomplete algorithm. The problem can be fixed either by using the step shown here instead (bottom-up Earley strategy) or by adding an additional step turning it into a bottom-up left-corner parser.",
                "cite_spans": [
                    {
                        "start": 37,
                        "end": 68,
                        "text": "Kahane, Nasr, and Rambow (1998)",
                        "ref_id": "BIBREF35"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Pseudo-Projectivity",
                "sec_num": "6.1"
            },
            {
                "text": "The non-projective parser of Attardi (2006) extends the algorithm of Yamada and Matsumoto (2003) , adding additional shift and reduce actions to handle non-projective dependency structures. These extra actions allow the parser to link to nodes that are several positions deep in the stack, creating non-projective links. In particular, Attardi uses six non-projective actions: two actions to link to nodes that are two positions deep, another two actions for nodes that are three positions deep, and a third pair of actions that generalizes the previous ones to n positions deep for any n. Thus, the maximum depth in the stack to which links can be created can be configured according to the actions allowed. We use Att d for the variant of the algorithm that allows links only up to depth d, and Att \u221e for the original, unrestricted algorithm with unlimited depth actions. A nondeterministic version of the algorithm Att d can be described as follows.",
                "cite_spans": [
                    {
                        "start": 29,
                        "end": 43,
                        "text": "Attardi (2006)",
                        "ref_id": "BIBREF2"
                    },
                    {
                        "start": 69,
                        "end": 96,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "Item set: The item set is",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "I Att = {[h 1 , h 2 , . . . , h m ] | 0 \u2264 h 1 < . . . < h m \u2264 n + 1} where [h 1 , h 2 , . . . , h m ]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "is the set of dependency forests of the form {T 1 , T 2 , . . . , T m } such that: ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "head(T i ) = h i for each i \u2208 [1",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "[i, i, i] [i + 1, i + 1, i + 1] [i, i + 1] COMBINE: [h 1 , h 2 , . . . , h m ] [h m , h m+1 , . . . , h p ] [h 1 , h 2 , . . . , h p ] LINK: [h 1 , h 2 , . . . , h m ] [h 1 , h 2 , . . . , h i\u22121 , h i+1 , . . . , h m ] (w h i , h i ) \u2192 (w h j , h j ), 1 < i < m, 1 \u2264 j \u2264 m, j = i, | j \u2212 i |\u2264 d",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "Deduction steps for Att \u221e are obtained by removing the constraint | j \u2212 i |\u2264 d from this set (this restriction corresponds to the maximum stack depth to which dependency links can be created).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "Final items: The set of final items is {[0, n + 1]}. Although similar to the final item set for Yamada and Matsumoto's parser, they differ in that an Attardi item of the form [0, n + 1] may contain forests with non-projective dependency trees.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "Given the number of indices manipulated in the schema, a nondeterministic implementation of Att d has exponential complexity with respect to input length (though in the implementation of Attardi [2006] , control structures determinize the algorithm). Soundness of the algorithm Att \u221e is shown as in the previous algorithms, and completeness can be shown by reasoning that every coherent final item [0, n + 1] can be obtained by first performing n + 1 INITTER steps to obtain items [i, i + 1] for each 0 \u2264 i \u2264 n, then using n COMBINERs to join all of these items into [0, 1, . . . , n, n + 1], and then performing the LINK steps corresponding to the links in a tree contained in [0, n + 1] to obtain this final item. The algorithm Att d where d is finite is not correct with respect to the set of non-projective dependency structures, because it only parses a restricted subset of them (Attardi 2006) . Note that the algorithm Att d is a static filter of Att d+1 for every natural number d, since the set of deduction steps of Att d is a subset of that of Att d+1 .",
                "cite_spans": [
                    {
                        "start": 187,
                        "end": 201,
                        "text": "Attardi [2006]",
                        "ref_id": "BIBREF2"
                    },
                    {
                        "start": 885,
                        "end": 899,
                        "text": "(Attardi 2006)",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Attardi (2006)",
                "sec_num": "6.2"
            },
            {
                "text": "We now define a novel variant of Attardi's parser with polynomial complexity by limiting the number of trees in each forest contained in an item (rather than limiting stack depth), producing a parsing schema MH k (standing for multi-headed with at most k heads per item). Its item set is",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The MH k Parser",
                "sec_num": "6.3"
            },
            {
                "text": "I MH k = {[h 1 , h 2 , . . . , h m ] | 0 \u2264 h 1 < . . . < h m \u2264 n + 1 \u2227 2 \u2264 m \u2264 k} where [h 1 , h 2 , . . . , h m ]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The MH k Parser",
                "sec_num": "6.3"
            },
            {
                "text": "is defined as in I Att , and the deduction steps are the following:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The MH k Parser",
                "sec_num": "6.3"
            },
            {
                "text": "INITTER: [i, i, i] [i + 1, i + 1, i + 1] [i, i + 1] COMBINE: [h 1 , h 2 , . . . , h m ] [h m , h m+1 , . . . , h p ] [h 1 , h 2 , . . . , h p ] p \u2264 k LINK: [h 1 , h 2 , . . . , h m ] [h 1 , h 2 , . . . , h i\u22121 , h i+1 , . . . , h m ] (w h i , h i ) \u2192 (w h j , h j ), 1 < i < m, 1 \u2264 j \u2264 m, j = i",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The MH k Parser",
                "sec_num": "6.3"
            },
            {
                "text": "As with the Att d parser, MH k parses a restricted subset of non-projective dependency structures, such that the set of structures parsed by MH k is always a subset of those parsed by MH k+1 . The MH \u221e parser, obtained by assuming that the number of trees per forest is unbounded, is equivalent to Att \u221e , and therefore correct with respect to the set of non-projective dependency structures. For finite values of k, MH d+2 is a static filter of Att d , because its sets of items and deduction steps are subsets of those of Att d . Therefore, the set of structures parsed by MH d+2 is also a subset of those parsed by Att d .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The MH k Parser",
                "sec_num": "6.3"
            },
            {
                "text": "The complexity of the MH k parser is O(n k ). For k = 3, MH 3 is a step refinement of the parser by Yamada and Matsumoto (2003) that parses projective structures only, but by modifying the bound k we can define polynomial-time algorithms that parse larger sets of non-projective dependency structures. The MH k parser has the property of being able to parse any possible dependency structure as long as we make k large enough.",
                "cite_spans": [
                    {
                        "start": 100,
                        "end": 127,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The MH k Parser",
                "sec_num": "6.3"
            },
            {
                "text": "McDonald et al. 2005describe a parser which finds a nonprojective analysis for a sentence in O(n 2 ) time under a strong independence assumption called an edgefactored model: Each dependency decision is assumed to be independent of all the others (McDonald and Satta 2007) . Despite the restrictiveness of this model, this maximum spanning tree (MST) parser achieves state-of-the-art performance for projective and non-projective structures (Che et al. 2008; Nivre and McDonald 2008; Surdeanu et al. 2008) . The parser considers the weighted graph formed by all the possible dependencies between pairs of input words, and applies an MST algorithm to find a dependency tree covering all the words in the sentence and maximizing the sum of weights.",
                "cite_spans": [
                    {
                        "start": 247,
                        "end": 272,
                        "text": "(McDonald and Satta 2007)",
                        "ref_id": "BIBREF46"
                    },
                    {
                        "start": 441,
                        "end": 458,
                        "text": "(Che et al. 2008;",
                        "ref_id": "BIBREF5"
                    },
                    {
                        "start": 459,
                        "end": 483,
                        "text": "Nivre and McDonald 2008;",
                        "ref_id": "BIBREF53"
                    },
                    {
                        "start": 484,
                        "end": 505,
                        "text": "Surdeanu et al. 2008)",
                        "ref_id": "BIBREF64"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "MST Parser (McDonald et al. 2005)",
                "sec_num": "6.4"
            },
            {
                "text": "The MST algorithm for directed graphs suggested by McDonald et al. 2005is not fully constructive: It does not work by building structures and combining them into large structures until it finds the solution. Instead, the algorithm works by using a greedy strategy to select a candidate set of edges for the spanning tree, potentially creating cycles and forming an illegal dependency tree. A cycle elimination procedure is iteratively applied to this graph until a legal dependency tree is obtained. It is still possible to express declarative aspects of the parser with a parsing schema, although the importance of the control mechanism in eliminating cycles makes this schema less informative than other cases we have considered, and we will not discuss it in detail here. G\u00f3mez-Rodr\u00edguez (2009) gives a complete description and discussion of the schema for the MST parser.",
                "cite_spans": [
                    {
                        "start": 775,
                        "end": 797,
                        "text": "G\u00f3mez-Rodr\u00edguez (2009)",
                        "ref_id": "BIBREF22"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "MST Parser (McDonald et al. 2005)",
                "sec_num": "6.4"
            },
            {
                "text": "Covington's non-projective parsing algorithm (Covington 1990 (Covington , 2001 ) reads the input from left to right, establishing dependency links between the current word and previous words in the input. The parser maintains two lists: one with all the words encountered so far, and one with those that do not yet have a head assigned. A new word can be linked as a dependent of any of the words in the first list, and as a head of any of the words in the second list. The following parsing schema expresses this algorithm.",
                "cite_spans": [
                    {
                        "start": 45,
                        "end": 60,
                        "text": "(Covington 1990",
                        "ref_id": "BIBREF9"
                    },
                    {
                        "start": 61,
                        "end": 78,
                        "text": "(Covington , 2001",
                        "ref_id": "BIBREF10"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Covington's (1990, 2001) Non-Projective Parser",
                "sec_num": "6.5"
            },
            {
                "text": "Item set: The item set is",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Covington's (1990, 2001) Non-Projective Parser",
                "sec_num": "6.5"
            },
            {
                "text": "I CovNP = {[i, h 1 , h 2 , . . . , h k ] | 1 \u2264 h 1 \u2264 . . . \u2264 h k \u2264 i \u2264 n} where an item [i, h 1 , h 2 , . . . , h k ]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Covington's (1990, 2001) Non-Projective Parser",
                "sec_num": "6.5"
            },
            {
                "text": "represents the set of forests of the form F = {T 1 , T 2 , . . . , T k } such that head(T j ) = h j for every T j in F; the projections of the nodes h 1 , h 2 , . . . , h k are pairwise disjoint, and their union is [1..i].",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Covington's (1990, 2001) Non-Projective Parser",
                "sec_num": "6.5"
            },
            {
                "text": "The set of deduction steps is as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "INITTER: [1, 1 ] R-LINK: [i, h 1 , . . . , h j\u22121 , h j , h j+1 , . . . , h k ] [i, h 1 , . . . , h j\u22121 , h j+1 , . . . , h k ] (w h j , h j ) \u2192 (w i , i)( j < i) ADVANCE: [i, h 1 , . . . , h k ] [i + 1, h 1 , . . . , h k , i + 1 ] L-LINK: [i, h 1 , . . . , h k , i ] [i, h 1 , . . . , h k ] (w i , i) \u2192 (w j , j)( j < i)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "Final items: The set of final items is {[n, h ] | 1 \u2264 h \u2264 n}, the set of items containing a forest with a single dependency tree T headed at an arbitrary position h of the string, and whose yield spans the whole input string. The time complexity of the algorithm is exponential in the input length n.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "Note that this parsing schema is not correct, because Covington's algorithm does not prevent the generation of cycles in the dependency graphs it produces. Quoting Covington (2001, page 99) ,",
                "cite_spans": [
                    {
                        "start": 164,
                        "end": 189,
                        "text": "Covington (2001, page 99)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "Because the parser operates one word at a time, unity can only be checked at the end of the whole process: did it produce a tree with a single root that comprises all of the words?",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "Therefore, a postprocessing mechanism is needed to determine which of the generated structures are, in fact, valid trees. In the parsing schema, this is reflected by the fact that the schema is complete but not sound. Nivre (2007) uses a variant of this algorithm in which cycle detection is used to avoid generating incorrect structures.",
                "cite_spans": [
                    {
                        "start": 218,
                        "end": 230,
                        "text": "Nivre (2007)",
                        "ref_id": "BIBREF49"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "Other non-projective parsers not covered here can also be represented under the parsing schema framework. For example, Kuhlmann (2010) presents a deduction system for a non-projective parser which uses a grammar formalism called regular dependency grammars. This deduction system can easily be converted into a parsing schema by associating adequate semantics with items. However, we do not show this here for space reasons, because we would first have to explain the formalism of regular dependency grammars.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deduction steps:",
                "sec_num": null
            },
            {
                "text": "For reasons of computational efficiency, many practical implementations of dependency parsing are restricted to projective structures. However, some natural language sentences appear to have non-projective syntactic structure, something that arises in many languages (Havelka 2007) , and is particularly common in free word order languages such as Czech. Parsing without the projectivity constraint is computationally complex: Although it is possible to parse non-projective structures in quadratic time with respect to input length under a model in which each dependency decision is independent of all the others (as in the parser of , discussed in Section 6.4), the problem is intractable in the absence of this assumption (McDonald and Satta 2007) . Nivre and Nilsson (2005) observe that most non-projective dependency structures appearing in practice contain only small proportions of non-projective arcs. This has led to the study of sub-classes of the class of all non-projective dependency structures (Kuhlmann and Nivre 2006; Havelka 2007) . Kuhlmann (2010) investigates several such classes, based on well-nestedness and gap degree constraints (Bodirsky, Kuhlmann, and M\u00f6hl 2005) , relating them to lexicalized constituency grammar formalisms. Specifically, Kuhlmann shows that linear context-free rewriting systems (LCFRS) with fan-out k (Vijay-Shanker, Weir, and Joshi 1987; Satta 1992) induce the set of dependency structures with gap degree at most k \u2212 1; coupled CFG in which the maximal rank of a nonterminal is k (Hotz and Pitsch 1996) induces the set of wellnested dependency structures with gap degree at most k \u2212 1; and finally, LTAG (Joshi and Schabes 1997) induces the set of well-nested dependency structures with gap degree at most 1.",
                "cite_spans": [
                    {
                        "start": 267,
                        "end": 281,
                        "text": "(Havelka 2007)",
                        "ref_id": "BIBREF30"
                    },
                    {
                        "start": 725,
                        "end": 750,
                        "text": "(McDonald and Satta 2007)",
                        "ref_id": "BIBREF46"
                    },
                    {
                        "start": 753,
                        "end": 777,
                        "text": "Nivre and Nilsson (2005)",
                        "ref_id": "BIBREF54"
                    },
                    {
                        "start": 1008,
                        "end": 1033,
                        "text": "(Kuhlmann and Nivre 2006;",
                        "ref_id": "BIBREF40"
                    },
                    {
                        "start": 1034,
                        "end": 1047,
                        "text": "Havelka 2007)",
                        "ref_id": "BIBREF30"
                    },
                    {
                        "start": 1050,
                        "end": 1065,
                        "text": "Kuhlmann (2010)",
                        "ref_id": "BIBREF38"
                    },
                    {
                        "start": 1153,
                        "end": 1188,
                        "text": "(Bodirsky, Kuhlmann, and M\u00f6hl 2005)",
                        "ref_id": "BIBREF4"
                    },
                    {
                        "start": 1348,
                        "end": 1385,
                        "text": "(Vijay-Shanker, Weir, and Joshi 1987;",
                        "ref_id": "BIBREF65"
                    },
                    {
                        "start": 1386,
                        "end": 1397,
                        "text": "Satta 1992)",
                        "ref_id": "BIBREF56"
                    },
                    {
                        "start": 1529,
                        "end": 1551,
                        "text": "(Hotz and Pitsch 1996)",
                        "ref_id": "BIBREF33"
                    },
                    {
                        "start": 1653,
                        "end": 1677,
                        "text": "(Joshi and Schabes 1997)",
                        "ref_id": "BIBREF34"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Mildly Non-Projective Dependency Parsing",
                "sec_num": "7."
            },
            {
                "text": "These results establish that there are polynomial-time dependency parsing algorithms for well-nested structures with bounded gap degree, because such parsers exist for their corresponding lexicalized constituency-based formalisms. Developing efficient dependency parsing strategies for these sets of structures has considerable practical interest, in particular, making it possible to parse directly with dependencies in a data-driven manner rather than indirectly by constructing intermediate constituency grammars and extracting dependencies from constituency parses. In this section, we make four contributions to this enterprise.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Mildly Non-Projective Dependency Parsing",
                "sec_num": "7."
            },
            {
                "text": "Firstly, we define a parser for well-nested structures of gap degree 1, and prove its correctness. The parser runs in time O(n 7 ), the same complexity as the best existing algorithms for LTAG (Eisner and Satta 2000) , and can be optimized to O(n 6 ) in the nonlexicalized case. Secondly, we generalize our algorithm to any well-nested dependency structure with gap degree at most k, resulting in an algorithm with time complexity O(n 5+2k ). Thirdly, we generalize the previous parsers in order to include ill-nested structures with gap degree at most k satisfying certain constraints, giving a parser that runs in time O(n 4+3k ). Note that parsing unrestricted ill-nested structures, even when the gap degree is bounded, is NP-complete: These structures are equivalent to LCFRS for which the recognition problem is NP-complete (Satta 1992) . Finally, we characterize the set of structures covered by this parser, which we call mildly ill-nested structures, and show that it includes all the trees present in a number of dependency treebanks.",
                "cite_spans": [
                    {
                        "start": 193,
                        "end": 216,
                        "text": "(Eisner and Satta 2000)",
                        "ref_id": "BIBREF19"
                    },
                    {
                        "start": 830,
                        "end": 842,
                        "text": "(Satta 1992)",
                        "ref_id": "BIBREF56"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Mildly Non-Projective Dependency Parsing",
                "sec_num": "7."
            },
            {
                "text": "We now define the concepts of gap degree and well-nestedness (Kuhlmann and Nivre 2006) . Let T be a dependency tree for the string w 1 . . . w n :",
                "cite_spans": [
                    {
                        "start": 61,
                        "end": 86,
                        "text": "(Kuhlmann and Nivre 2006)",
                        "ref_id": "BIBREF40"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Mildly Non-Projective Dependency Parsing",
                "sec_num": "7."
            },
            {
                "text": "The gap degree of a node k in T is the minimum g \u2208 (N \u222a {0}) such that k (the projection of the node k) can be written as the union of g + 1 intervals, that is, the number of discontinuities in k . The gap degree of the dependency tree T is the maximum of the gap degrees of its nodes.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5",
                "sec_num": null
            },
            {
                "text": "Note that T has gap degree 0 if and only if T is projective.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5",
                "sec_num": null
            },
            {
                "text": "The subtree induced by the node u in a dependency tree T is the tree",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 6",
                "sec_num": null
            },
            {
                "text": "T u = ( u , E u ) where E u = {i \u2192 j \u2208 E | j \u2208 u }.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 6",
                "sec_num": null
            },
            {
                "text": "The subtrees induced by nodes p and q are interleaved if p \u2229 q = \u2205 and there are nodes i, j \u2208 p and k, l \u2208 q such that i < k < j < l. A dependency tree T is well-nested if it does not contain two interleaved subtrees, and a tree that is not well-nested is said to be ill-nested.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 6",
                "sec_num": null
            },
            {
                "text": "Projective trees are always well-nested, but well-nested trees are not always projective.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 6",
                "sec_num": null
            },
            {
                "text": "We now define WG 1 , a polynomial-time parser for well-nested dependency structures of gap degree at most 1. In this and subsequent schemata, each dependency forest in an item is a singleton set containing a dependency tree, so we will not make explicit mention of these forests, referring directly to their trees instead. Also note that in the parsers in this section we use D-rules to express parsing decisions, so dependency trees are assumed to be taken from the set of trees licensed by a given set of D-rules. The schema for the WG 1 parser is defined as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "Item set: The item set is I WG1 = I 1 \u222a I 2 , with",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "I 1 = {[i, j, h, , ] | i, j, h \u2208 N, 1 \u2264 h \u2264 n, 1 \u2264 i \u2264 j \u2264 n, h = j, h = i \u2212 1}",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "where each item of the form [i, j, h, , ] represents the set of all well-nested dependency trees with gap degree at most 1, rooted at h, and such that h = {h} \u222a [i..j], and",
                "cite_spans": [
                    {
                        "start": 28,
                        "end": 41,
                        "text": "[i, j, h, , ]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "I 2 = {[i, j, h, l, r] | i, j, h, l, r \u2208 N, 1 \u2264 h \u2264 n, 1 \u2264 i < l \u2264 r < j \u2264 n, h = j, h = i \u2212 1, h = l \u2212 1, h = r}",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "where each item of the form [i, j, h, l, r] represents the set of all well-nested dependency trees rooted at h such that h = {h} \u222a ([i..j] \\ [l..r]), and all the nodes (except possibly h) have gap degree at most 1. We call items of this form gapped items, and the interval [l..r] the gap of the item. Figure 7 shows two WG 1 items, one from I 1 and the other from I 2 , together with one of the trees contained in each of them. Note that the constraints h = j, h = i + 1, h = l \u2212 1, h = r are added to items to avoid redundancy in the item set. Because the result of the expression {h} \u222a ([i..j] \\ [l..r]) for a given head can be the same for different sets of values of i, j, l, r, we restrict these values so that we cannot get two different items representing the same dependency structures. Items \u03b9 violating these constraints always have an alternative representation that does not violate them, which we can express with a normalizing function nm(\u03b9) as follows:",
                "cite_spans": [
                    {
                        "start": 28,
                        "end": 43,
                        "text": "[i, j, h, l, r]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 301,
                        "end": 309,
                        "text": "Figure 7",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "nm ([i, j, j, l, r] ",
                "cite_spans": [
                    {
                        "start": 3,
                        "end": 19,
                        "text": "([i, j, j, l, r]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": ") = [i, j \u2212 1, j, l, r] (if r \u2264 j \u2212 1 or r = ), or [i, l \u2212 1, j, , ] (if r = j \u2212 1). nm([i, j, l \u2212 1, l, r]) = [i, j, l \u2212 1, l \u2212 1, r](if l > i + 1), or [r + 1, j, l \u2212 1, , ] (if l = i + 1). nm([i, j, i \u2212 1, l, r]) = [i \u2212 1, j, i \u2212 1, l, r].",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "nm ([i, j, r, l, r] ",
                "cite_spans": [
                    {
                        "start": 3,
                        "end": 19,
                        "text": "([i, j, r, l, r]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": ") = [i, j, r, l, r \u2212 1] (if l < r), or [i, j, r, , ] (if l = r).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "nm ([i, j, h, l, r] j, h, l, r] for all other items.",
                "cite_spans": [
                    {
                        "start": 3,
                        "end": 19,
                        "text": "([i, j, h, l, r]",
                        "ref_id": null
                    },
                    {
                        "start": 20,
                        "end": 31,
                        "text": "j, h, l, r]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": ") = [i,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "When defining the deduction steps for this and other parsers, we assume that they always produce normalized items. For clarity, we do not explicitly write this in the deduction steps, writing \u03b9 instead of nm(\u03b9) as antecedents and consequents of steps.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG 1 Parser",
                "sec_num": "7.1"
            },
            {
                "text": "Representation of the WG 1 items [i, j, h, , ] and [i, j, h, l, r] , each together with one of the dependency structures contained in it.",
                "cite_spans": [
                    {
                        "start": 33,
                        "end": 46,
                        "text": "[i, j, h, , ]",
                        "ref_id": null
                    },
                    {
                        "start": 51,
                        "end": 66,
                        "text": "[i, j, h, l, r]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "Initial items: The set of initial items (hypotheses) is defined as the set",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "H = {[h, h, h, , ] | h \u2208 [1..n]}",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "where each item [h, h, h, , ] represents the set containing the trivial dependency tree consisting of a single node h and no links. This is the same set of hypotheses used by the parsers defined in previous sections, but we use the notation [h, h, h, , ] rather than [h, h, h] here for convenience when defining deduction steps. The same set of hypotheses is used for all the mildly non-projective parsers, so we do not make it explicit for subsequent schemata. Note that initial items are separate from the item set I WG1 and not subject to its constraints, so they do not require normalization.",
                "cite_spans": [
                    {
                        "start": 16,
                        "end": 29,
                        "text": "[h, h, h, , ]",
                        "ref_id": null
                    },
                    {
                        "start": 241,
                        "end": 254,
                        "text": "[h, h, h, , ]",
                        "ref_id": null
                    },
                    {
                        "start": 267,
                        "end": 276,
                        "text": "[h, h, h]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "Final items: The set of final items for strings of length n in WG 1 is defined as the set",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "F = {[1, n, h, , ] | h \u2208 [1..n]},",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "which is the set of the items in I WG1 containing dependency trees for the complete input string (from position 1 to n), with their head at any position h.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "Deduction steps: The deduction steps of the WG 1 parser are the following:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "LINK UNGAPPED: [h 1 , h 1 , h 1 , , ] [i 2 , j 2 , h 2 , , ] [i 2 , j 2 , h 1 , , ] (w h 2 , h 2 ) \u2192 (w h 1 , h 1 ) such that h 2 \u2208 [i 2 ..j 2 ] \u2227 h 1 / \u2208 [i 2 ..j 2 ]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "LINK GAPPED:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "[h 1 , h 1 , h 1 , , ] [i 2 , j 2 , h 2 , l 2 , r 2 ] [i 2 , j 2 , h 1 , l 2 , r 2 ] (w h 2 , h 2 ) \u2192 (w h 1 , h 1 ) such that h 2 \u2208 [i 2 ..j 2 ] \\ [l 2 ..r 2 ] \u2227 h 1 / \u2208 [i 2 ..j 2 ] \\ [l 2 ..r 2 ]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "COMBINE UNGAPPED:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "[i, j, h, , ] [ j + 1, k, h, , ] [i, k, h, , ] COMBINE OPENING GAP: [i, j, h, , ] [k, l, h, , ] [i, l, h, j + 1, k \u2212 1] j < k \u2212 1 COMBINE KEEPING GAP LEFT: [i, j, h, l, r] [ j + 1, k, h, , ] [i, k, h, l, r] COMBINE KEEPING GAP RIGHT: [i, j, h, , ] [ j + 1, k, h, l, r] [i, k, h, l, r] COMBINE CLOSING GAP: [i, j, h, l, r] [l, r, h, , ] [i, j, h, , ]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "COMBINE SHRINKING GAP CENTRE:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "[i, j, h, l, r] [l, r, h, l 2 , r 2 ] [i, j, h, l 2 , r 2 ] COMBINE SHRINKING GAP LEFT: [i, j, h, l, r] [l, k, h, , ] [i, j, h, k + 1, r] COMBINE SHRINKING GAP RIGHT: [i, j, h, l, r] [k, r, h, , ] [i, j, h, l, k \u2212 1]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "The WG 1 parser proceeds bottom-up, building dependency subtrees and combining them into larger subtrees, until a complete dependency tree for the input sentence is found. The parser logic specifies how items corresponding to the subtree induced by a particular node are inferred, given the items for the subtrees induced by the direct dependents of that node. Suppose that, in a complete dependency analysis for a sentence w 1 . . . w n , the node h has d 1 . . . d p as direct dependents (i.e., we have dependency links",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "d 1 \u2192 h, . . . , d p \u2192 h).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "The item corresponding to the subtree induced by h is obtained from the ones corresponding to the subtrees induced by d 1 . . . d p as follows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "First, apply the LINK UNGAPPED or LINK GAPPED step to each of the items corresponding to the subtrees induced by the direct dependents, and to the hypothesis [h, h, h, , ] . We infer p items representing the result of linking each of the dependent subtrees to the new head h. Second, apply the various COMBINE steps to join all items obtained in the previous step into a single item. The COMBINE steps perform a union operation between subtrees. Therefore, the result is a dependency tree containing all the dependent subtrees, and with all of them linked to h-this is the subtree induced by h. This process is applied repeatedly to build larger subtrees, until, if the parsing process is successful, a final item is found containing a dependency tree for the complete sentence. A graphical representation of this process is shown in Figure 8 .",
                "cite_spans": [
                    {
                        "start": 158,
                        "end": 171,
                        "text": "[h, h, h, , ]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 834,
                        "end": 842,
                        "text": "Figure 8",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "Example WG 1 parse, following the notation of Figure 7 . LINK steps link an item to a new head, while COMBINE steps are used to join a pair of items sharing the same head. Different COMBINE steps correspond to different relative positions of items that can be joined and their gaps.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 46,
                        "end": 54,
                        "text": "Figure 7",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 8",
                "sec_num": null
            },
            {
                "text": "The WG 1 schema provides an abstract mechanism for finding all the dependency structures in the class of well-nested structures of gap degree at most 1, for an input string under a set of D-rules. Concrete implementations of the schema may use probabilistic models or machine learning techniques to make the linking decisions associated with the D-rules, as explained in Section 3.1. The definition of such statistical models for guiding the execution of schemata falls outside the scope of this article.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 8",
                "sec_num": null
            },
            {
                "text": "We define a set of coherent items for the schema, in such a way that final items in this set satisfy the general definition of coherent final items; and then prove the stronger claims that all derivable items are coherent and all coherent items are derivable. The full correctness proof has previously been published G\u00f3mez-Rodr\u00edguez 2009) , so for reasons of space we only sketch the proof here.",
                "cite_spans": [
                    {
                        "start": 317,
                        "end": 338,
                        "text": "G\u00f3mez-Rodr\u00edguez 2009)",
                        "ref_id": "BIBREF22"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Correctness for WG 1",
                "sec_num": "7.2"
            },
            {
                "text": "To define the set of coherent items for WG 1 , we provide a definition of the trees that these items must contain. Let T be a well-nested dependency tree headed at a node h, with all its edges licensed by our set of D-rules. We call such a tree a properly formed tree for the algorithm WG 1 if it satisfies the following conditions.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Correctness for WG 1",
                "sec_num": "7.2"
            },
            {
                "text": "h 1, n, h, , ] for an input string contains at least one well-nested parse of gap degree \u2264 1 for that string. With these sets of coherent and coherent final items, we prove the soundness and completeness of WG 1 .",
                "cite_spans": [
                    {
                        "start": 2,
                        "end": 14,
                        "text": "1, n, h, , ]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "1.",
                "sec_num": null
            },
            {
                "text": "WG 1 is sound.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 6",
                "sec_num": null
            },
            {
                "text": "Proving the soundness of the WG 1 parser involves showing that all derivable final items are coherent. We do this by proving the stronger claim that all derivable items are coherent. As in previous proofs, this is done by showing that each deduction step in the parser infers a coherent consequent item when applied to coherent antecedents. We proceed step by step, showing that if each of the antecedents of a given step contains at least one properly formed tree, we obtain a properly formed tree that is an element of the corresponding consequent. In the case of LINK steps, this properly formed consequent tree is obtained by creating a dependency link between the heads of the properly formed antecedent trees; for COMBINE steps, it is obtained from the union of the antecedent trees. To prove that these consequent trees are properly formed, we show that they are well-nested, have a projection corresponding to the indices in the consequent item, and satisfy the gap degree constraint 2 required for the trees to be properly formed. Each of these properties is proven individually, based on the properties of the antecedent trees.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 6",
                "sec_num": null
            },
            {
                "text": "Theorem 7 WG 1 is complete.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 6",
                "sec_num": null
            },
            {
                "text": "Proving completeness of the WG 1 parser involves proving that all coherent final items in WG 1 are derivable. We show this by proving the following, stronger claim.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 7",
                "sec_num": null
            },
            {
                "text": "If T is a dependency tree headed at a node h, which is a properly formed tree for WG 1 , then:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": "1. If h = {h} \u222a [i.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": ".j], then the item [i, j, h, , ] containing T is a derivable item in the WG 1 parser.",
                "cite_spans": [
                    {
                        "start": 19,
                        "end": 32,
                        "text": "[i, j, h, , ]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": "2.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": "If h = {h} \u222a ([i..j] \\ [l.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": ".r]), then the item [i, j, h, l, r] containing T is a derivable item in the WG 1 parser.",
                "cite_spans": [
                    {
                        "start": 20,
                        "end": 35,
                        "text": "[i, j, h, l, r]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": "This implies that all coherent final items are derivable, and therefore that WG 1 is complete. The lemma is proven by strong induction on the number of elements in h , which we denote #( h ). The base case of the induction is trivial, because the case #( h ) = 1 corresponds to a tree contained in an initial item, which is derivable by definition. For the induction step, we take T to be a properly formed dependency tree rooted at a node h, such that #( h ) = N for some N > 1. Lemma 1 holds for T if it holds for every properly formed dependency tree T rooted at h such that #( h ) < N. Let p be the number of direct children of h in the tree T. We have p \u2265 1, because by hypothesis #( h ) > 1. With this, the induction step proof is divided into two cases, according to whether p = 1 or p > 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": "When p = 1, the item that Lemma 1 associates with the subtree of T induced by the single direct dependent of h is known to be derivable by the induction hypothesis. It can be shown case by case that the item corresponding to h by Lemma 1 can be inferred using LINK steps, thus completing the case for p = 1. For p > 1, we use the concept of order annotations (Kuhlmann and M\u00f6hl 2007; Kuhlmann 2010) . Order annotations are strings that encode the precedence relation between the nodes of a dependency tree. The order annotation for a given node encodes the shape (with respect to this precedence relation) of the projection of each of the children of that node, that is, the number of intervals in each projection, the number of gaps, and the way in which intervals and gaps are interleaved. The concepts of projectivity, gap degree, and well-nestedness are associated with particular constraints on order annotations.",
                "cite_spans": [
                    {
                        "start": 359,
                        "end": 383,
                        "text": "(Kuhlmann and M\u00f6hl 2007;",
                        "ref_id": "BIBREF39"
                    },
                    {
                        "start": 384,
                        "end": 398,
                        "text": "Kuhlmann 2010)",
                        "ref_id": "BIBREF38"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": "The completeness proof for p > 1 is divided into cases according to the order annotation of the head h. The fact that the tree T is properly formed imposes constraints on the form of this order annotation. With this information, we divide the possible order annotations into a number of cases. Using the induction hypotheses and some relevant properties of order annotations we find that, for each of this cases, we can find a sequence of COMBINE steps to infer the item corresponding to T from smaller coherent items.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": "The time complexity of WG 1 is O(n 7 ), as the step COMBINE SHRINKING GAP CENTRE works with seven free string positions. This complexity with respect to the length of the input is as expected for this set of structures, because Kuhlmann (2010) shows that they are equivalent to LTAG, and the best existing parsers for this formalism also perform in O(n 7 ) (Eisner and Satta 2000) . 9 Note that the COMBINE step that is the bottleneck only uses seven indices, not any additional entities such as D-rules. Hence, the O(n 7 ) complexity does not involve additional factors relating to grammar size.",
                "cite_spans": [
                    {
                        "start": 228,
                        "end": 243,
                        "text": "Kuhlmann (2010)",
                        "ref_id": "BIBREF38"
                    },
                    {
                        "start": 357,
                        "end": 380,
                        "text": "(Eisner and Satta 2000)",
                        "ref_id": "BIBREF19"
                    },
                    {
                        "start": 383,
                        "end": 384,
                        "text": "9",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Computational Complexity of WG 1",
                "sec_num": "7.3"
            },
            {
                "text": "Given unlexicalized D-rules specifying the possibility of dependencies between pairs of categories rather than pairs of words, a variant of this parser can be constructed with time complexity O(n 6 ), as with parsers for unlexicalized TAG. We expand the item set with unlexicalized items of the form [i, j, C, l, r] , where C is a category, distinct from the existing items [i, j, h, l, r] . Steps in the parser are duplicated, to work both with lexicalized and unlexicalized items, except for the LINK steps, which always work with a lexicalized item and an unlexicalized hypothesis to produce an unlexicalized item, and the COMBINE SHRINKING GAP steps, which work only with unlexicalized items.",
                "cite_spans": [
                    {
                        "start": 300,
                        "end": 315,
                        "text": "[i, j, C, l, r]",
                        "ref_id": null
                    },
                    {
                        "start": 374,
                        "end": 389,
                        "text": "[i, j, h, l, r]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Computational Complexity of WG 1",
                "sec_num": "7.3"
            },
            {
                "text": "Steps are added to obtain lexicalized items from their unlexicalized equivalents by binding the head to particular string positions. Finally, we need certain variants of the COMBINE SHRINKING GAP steps that take two unlexicalized antecedents and produce a lexicalized consequent; an example is the following:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Computational Complexity of WG 1",
                "sec_num": "7.3"
            },
            {
                "text": "COMBINE SHRINKING GAP CENTRE L: [i, j, C, l, r] [l + 1, r, C, l 2 , r 2 ] [i, j, l, l 2 , r 2 ] cat(w l )=C",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Computational Complexity of WG 1",
                "sec_num": "7.3"
            },
            {
                "text": "Although this version of the algorithm reduces time complexity to O(n 6 ), it also adds a factor related to the number of categories, as well as constant factors due to having more kinds of items and steps than the original WG 1 algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Computational Complexity of WG 1",
                "sec_num": "7.3"
            },
            {
                "text": "The WG 1 parsing schema can be generalized to obtain a parser for all well-nested dependency structures with gap degree bounded by a constant k (k \u2265 1), which we call the WG k parser. We extend the item set so that it contains items with up to k gaps, and modify the deduction steps to work with these multi-gapped items.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "Item set: The item set for the WG k parsing schema is r g ) ] represents the set of all well-nested dependency trees rooted at h such that",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 54,
                        "end": 57,
                        "text": "r g",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "I WGk = {[i, j, h, (l 1 , r 1 ), . . . , (l g , r g ) ]} where i, j, h \u2208 (N \u222a {0}), 0 \u2264 g \u2264 k, 1 \u2264 h \u2264 n, 1 \u2264 i \u2264 j \u2264 n, h = j, h = i \u2212 1; and for each p \u2208 {1, 2, . . . , g}: l p , r p \u2208 N, i < l p \u2264 r p < j, r p < l p+1 \u2212 1, h = l p \u2212 1, h = r p . An item [i, j, h, (l 1 , r 1 ), . . . , (l g ,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "h = {h} \u222a ([i..j] \\ g p=1 [l p ..r p ]), where each interval [l p ..r p ]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "is called a gap. The constraints h = j, h = i + 1, h = l p \u2212 1, h = r p are added to avoid redundancy, and normalization is defined as in WG 1 .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "Final items: The set of final items is defined as the set",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "F = {[1, n, h, ] | h \u2208 [1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": ".n]}. Note that this set is the same as in WG 1 , as these are the items that we denoted [1, n, h, , ] in that parser.",
                "cite_spans": [
                    {
                        "start": 89,
                        "end": 102,
                        "text": "[1, n, h, , ]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "Deduction steps: The parser has the following deduction steps:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "LINK: [h 1 , h 1 , h 1 , ] [i 2 , j 2 , h 2 , (l 1 , r 1 ), . . . , (l g , r g ) ] [i 2 , j 2 , h 1 , (l 1 , r 1 ), . . . , (l g , r g ) ] (w h 2 , h 2 ) \u2192 (w h 1 , h 1 ) such that h 2 \u2208 [i 2 ..j 2 ] \\ g p=1 [l p ..r p ] \u2227 h 1 / \u2208 [i 2 ..j 2 ] \\ g p=1 [l p ..r p ] COMBINE OPENING GAP: [i, l q \u2212 1, h, (l 1 , r 1 ), . . . , (l q\u22121 , r q\u22121 ) ] [r q + 1, m, h, (l q+1 , r q+1 ), . . . , (l g , r g ) ] [i, m, h, (l 1 , r 1 ), . . . , (l g , r g ) ] g \u2264 k \u2227 l q \u2264 r q COMBINE KEEPING GAPS: [i, j, h, (l 1 , r 1 ), . . . , (l q , r q ) ] [ j + 1, m, h, (l q+1 , r q+1 ), . . . , (l g , r g ) ] [i, m, h, (l 1 , r 1 ), . . . , (l g , r g ) ] g \u2264 k COMBINE SHRINKING GAP LEFT: [i, j, h, (l 1 , r 1 ), . . . , (l q , r q ), (l , r s ), (l s+1 , r s+1 ), . . . , (l g , r g ) ] [l , l s \u2212 1, h, (l q+1 , r q+1 ), . . . , (l s\u22121 , r s\u22121 ) ] [i, j, h, (l 1 , r 1 ), . . . , (l g , r g ) ] g \u2264 k COMBINE SHRINKING GAP RIGHT: [i, j, h, (l 1 , r 1 ), . . . , (l q\u22121 , r q\u22121 ), (l q , r ), (l s , r s ), . . . , (l g , r g ) ] [r q + 1, r , h, (l q+1 , r q+1 ), . . . , (l s\u22121 , r s\u22121 ) ] [i, j, h, (l 1 , r 1 ), . . . , (l g , r g ) ] g \u2264 k COMBINE SHRINKING GAP CENTRE: [i, j, h, (l 1 , r 1 ), . . . , (l q , r q ), (l , r ), (l s , r s ), . . . , (l g , r g ) ] [l , r , h, (l q+1 , r q+1 ), . . . , (l s\u22121 , r s\u22121 ) ] [i, j, h, (l 1 , r 1 ), . . . , (l g , r g ) ] g \u2264 k",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "As expected, the WG 1 parser corresponds to WG k for k = 1. WG k works in the same way as WG 1 , except that COMBINE steps can create items with more than one gap. In all the parsers described in this section, COMBINE steps may be applied in different orders to produce the same result, causing spurious ambiguity. In WG 1 and WG k , this can be avoided when implementing the schemata by adding flags to items so as to impose a particular order on the execution of these steps.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The WG k Parser",
                "sec_num": "7.4"
            },
            {
                "text": "The proof of correctness for WG k is analogous to that of WG 1 , but generalizing the definition of properly formed trees to a higher gap degree. A properly formed tree in WG k is a dependency tree T, headed at node h, such that the following hold.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Correctness for WG k",
                "sec_num": "7.5"
            },
            {
                "text": "([i..j] \\ g p=1 [l p ..r p ]), with 0 \u2264 g \u2264 k. 2.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "h is of the form {h} \u222a",
                "sec_num": "1."
            },
            {
                "text": "All the nodes in T have gap degree at most k except for h, which can have gap degree up to k + 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "h is of the form {h} \u222a",
                "sec_num": "1."
            },
            {
                "text": "With this, we define coherent items and coherent final items as for WG 1 . Soundness is shown as for WG 1 , changing the constraints on nodes so that any node can have gap degree up to k and the head of a properly formed tree can have gap degree k + 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "h is of the form {h} \u222a",
                "sec_num": "1."
            },
            {
                "text": "Completeness is shown by induction on #( h ). The base case is the same as for WG 1 , and for the induction step, we consider the direct children",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "h is of the form {h} \u222a",
                "sec_num": "1."
            },
            {
                "text": "d 1 . . . d p of h.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "h is of the form {h} \u222a",
                "sec_num": "1."
            },
            {
                "text": "The case where p = 1 is proven by using LINK steps just as in WG 1 . In the case for p \u2265 1, we also base our proof on the order annotation for h, but we have to take into account that the set of possible annotations is larger when we allow the gap degree to be greater than 1, so we must consider more cases in this part of the proof.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "h is of the form {h} \u222a",
                "sec_num": "1."
            },
            {
                "text": "The WG k parser runs in time O(n 5+2k ). As in the case of WG 1 , the step with most free variables is COMBINE SHRINKING GAP CENTRE with 5 + 2k free indices. Again, this complexity result is in line with what could be expected from previous research in constituency parsing: Kuhlmann (2010) shows that the set of well-nested dependency structures with gap degree at most k is closely related to coupled CFG in which the maximal rank of a nonterminal is k + 1. The constituency parser defined by Hotz and Pitsch (1996) for these grammars also adds an n 2 factor for each unit increment of k. Note that a small value of k appears to be sufficient to account for the vast majority of the non-projective sentences found in natural language treebanks. For instance, the Prague Dependency Treebank (Haji\u010d et al. 2006) contains no structures with gap degree greater than 4. Thus, a WG 4 parser would be able to analyze all the well-nested structures in this treebank, which represent 99.89% of the total (WG 1 would be able to parse 99.49%).",
                "cite_spans": [
                    {
                        "start": 275,
                        "end": 290,
                        "text": "Kuhlmann (2010)",
                        "ref_id": "BIBREF38"
                    },
                    {
                        "start": 495,
                        "end": 517,
                        "text": "Hotz and Pitsch (1996)",
                        "ref_id": "BIBREF33"
                    },
                    {
                        "start": 792,
                        "end": 811,
                        "text": "(Haji\u010d et al. 2006)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Computational Complexity of WG k",
                "sec_num": "7.6"
            },
            {
                "text": "Increasing k beyond 4 would not produce further improvements in coverage.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Computational Complexity of WG k",
                "sec_num": "7.6"
            },
            {
                "text": "The WG k parser analyzes dependency structures with bounded gap degree as long as they are well-nested. Although this covers the vast majority of the structures that occur in natural language treebanks (Kuhlmann and Nivre 2006) , a significant number of sentences contain ill-nested structures. Maier and Lichte (2011) provide examples of some linguistic phenomena that cause ill-nestedness. Unfortunately, the general problem of parsing ill-nested structures is NP-complete, even when the gap degree is bounded. This set of structures is closely related to LCFRS with bounded fan-out and unbounded production length, and parsing in this formalism is known to be NP-complete (Satta 1992) . The reason for this complexity is the problem of unrestricted crossing configurations, appearing when dependency subtrees are allowed to interleave in every possible way. Ill-nested structures can be parsed in polynomial time with bounds on the gap degree and the number of dependents allowed per node: Kuhlmann (2010) presents a parser based on this idea, using a kind of grammar that resembles LCFRS, called regular dependency grammar. This parser is exponential in the gap degree, as well as in the maximum number of dependents allowed per node: Its complexity is O(n k(m+1) ), where k is the maximum gap degree and m is the maximum number of dependents per node. In contrast, the parsers presented here are data-driven and thus do not need an explicit grammar. Furthermore, they are able to parse dependency structures with any number of dependents per node, and their computational complexity is independent of this parameter m.",
                "cite_spans": [
                    {
                        "start": 202,
                        "end": 227,
                        "text": "(Kuhlmann and Nivre 2006)",
                        "ref_id": "BIBREF40"
                    },
                    {
                        "start": 675,
                        "end": 687,
                        "text": "(Satta 1992)",
                        "ref_id": "BIBREF56"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Parsing Ill-Nested Structures: MG 1 and MG k",
                "sec_num": "7.7"
            },
            {
                "text": "In line with the observation that most non-projective structures appearing in practice are only \"slightly\" non-projective (Nivre and Nilsson 2005) , we characterize a sense in which the structures appearing in treebanks are only \"slightly\" ill-nested. We generalize the algorithms WG 1 and WG k to parse a proper superset of the set of wellnested structures in polynomial time, and give a characterization of this new set of structures, which includes all the structures in several dependency treebanks.",
                "cite_spans": [
                    {
                        "start": 122,
                        "end": 146,
                        "text": "(Nivre and Nilsson 2005)",
                        "ref_id": "BIBREF54"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Parsing Ill-Nested Structures: MG 1 and MG k",
                "sec_num": "7.7"
            },
            {
                "text": "The WG k parser for well-nested structures presented previously is based on a bottom-up process, where LINK steps are used to link completed subtrees to a head, and COMBINE steps are used to join subtrees governed by a common head to obtain a larger structure. As WG k is a parser for well-nested structures of gap degree up to k, its COMBINER steps correspond to all the ways in which we can join two sets of sibling subtrees meeting these constraints, and having a common head, into another. Therefore, this parser does not use COMBINER steps that produce interleaved subtrees, because these would generate items corresponding to ill-nested structures.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Parsing Ill-Nested Structures: MG 1 and MG k",
                "sec_num": "7.7"
            },
            {
                "text": "We obtain a polynomial parser for a larger set of structures of gap degree at most k, including some ill-nested ones, by having COMBINER steps representing all ways in which two sets of sibling subtrees of gap degree at most k with a common head can be joined into another, including those producing interleaved subtrees. This does not mean that we build every possible ill-nested structure. Some structures with complex crossed configurations have gap degree k, but cannot be built by combining two structures of that gap degree. More specifically, this algorithm will parse a dependency structure (well-nested or not) if there exists a binarization of that structure that has gap degree at most k. The parser works by implicitly finding such a binarization, because COMBINE steps are always applied to two items and no intermediate item generated by them can exceed gap degree k (not counting the position of the head in the projection).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Parsing Ill-Nested Structures: MG 1 and MG k",
                "sec_num": "7.7"
            },
            {
                "text": "Let w 1 . . . w n be a string, and T a dependency tree headed at a node h. A binarization of T is a tree B in which each node has at most two children, such that:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 7",
                "sec_num": null
            },
            {
                "text": "Each node in B can be unlabelled, or labelled with a word position i. Several nodes may have the same label (in contrast to the dependency graphs, where a word occurrence cannot appear twice in the graph).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "1.",
                "sec_num": null
            },
            {
                "text": "A node labelled i is a descendant of j in B if and only if i \u2192 j in T.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "2.",
                "sec_num": null
            },
            {
                "text": "The projection of a node in a binarization is the set of reflexive-transitive children of that node. With this, condition (2) of Definition 7 can be rewritten i \u2208 j B \u21d4 i \u2208 j T , and the gap degree of a binarization can be defined as with a dependency structure, allowing us to define mildly ill-nested structures as follows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "2.",
                "sec_num": null
            },
            {
                "text": "A dependency structure is mildly ill-nested for gap degree k if it has at least one binarization of gap degree \u2264 k. Otherwise, it is strongly ill-nested for gap degree k.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "The set of mildly ill-nested structures for gap degree k includes all well-nested structures with gap degree up to k. We define MG 1 , a parser for mildly ill-nested structures for gap degree 1, as follows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "Item set and final item set: The item set and the final item set are the same as for WG 1 , except that items can contain any mildly ill-nested structures for gap degree 1, instead of being restricted to well-nested structures.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "Deduction steps: Deduction steps include those in WG 1 , plus the following.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "COMBINE INTERLEAVING: [i, j, h, l, r] [l, k, h, r + 1, j] [ i, k, h, , ] COMBINE INTERLEAVING GAP C: [i, j, h, l, r] [l, k, h, m, j] [i, k, h, m, r] ",
                "cite_spans": [
                    {
                        "start": 22,
                        "end": 57,
                        "text": "[i, j, h, l, r] [l, k, h, r + 1, j]",
                        "ref_id": null
                    },
                    {
                        "start": 60,
                        "end": 72,
                        "text": "i, k, h, , ]",
                        "ref_id": null
                    },
                    {
                        "start": 101,
                        "end": 148,
                        "text": "[i, j, h, l, r] [l, k, h, m, j] [i, k, h, m, r]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "m < r + 1 COMBINE INTERLEAVING GAP L: [i, j, h, l, r] [l, k, h, r + 1, u] [i, k, h, j + 1, u] u > j COMBINE INTERLEAVING GAP R: [i, j, h, l, r] [k, m, h, r + 1, j] [i, m, h, l, k \u2212 1] k > l",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "These extra COMBINE steps allow the parser to combine interleaved subtrees with simple crossing configurations. The MG 1 parser still runs in O(n 7 ), as these new steps do not use more than seven string positions. To generalize this algorithm to mildly ill-nested structures for gap degree k, we add a COMBINE step for every possible way of joining two structures of gap degree at most k into another. This is done in a systematic way by considering a set of strings over an alphabet of three symbols: a and b to represent intervals of words in the projection of each of the structures, and g to represent intervals that are not in the projection of either of the structures and will correspond to gaps in the joined structure. The legal combinations of structures for gap degree k will correspond to strings where symbols a and b each appear at most k + 1 times, g appears at most k times and is not the first or last symbol, and there is no more than one consecutive appearance of any symbol. Given a string of this form, of length n, with a's located at positions a 1 . .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": ". a p (1 \u2264 a 1 < . . . < a p \u2264 n), b's at positions b 1 . . . b q (1 \u2264 b 1 < . . . < b q \u2264 n), and g's at positions g 1 . . . g r (2 \u2264 g 1 < . . . < g r \u2264 n \u2212 1)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": ", such that p + q + r = n, the corresponding COMBINE step is as follows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "[i a 1 , i a p +1 \u2212 1, h, (i a 1 +1 , i a 2 \u2212 1), . . . , (i a p\u22121 +1 , i a p \u2212 1) ] [i b 1 , i b q +1 \u2212 1, h, (i b 1 +1 , i b 2 \u2212 1), . . . , (i b q\u22121 +1 , i b q \u2212 1) ] [i min(a 1 ,b 1 ) , i max(a p +1,b q +1) \u2212 1, h, (i g 1 , i g 1 +1 \u2212 1), . . . , (i g r , i g r +1 \u2212 1) ]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "For example, the COMBINE INTERLEAVING GAP C step in MG 1 is obtained from the string abgab. Therefore, we define the parsing schema for MG k , a parser for mildly illnested structures for gap degree k, as the schema where the item set is the same as that of WG k , except that items now contain mildly ill-nested structures for gap degree k; and the set of deduction steps consists of the LINK step in WG k , plus a set of COMBINE steps obtained as explained herein.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 8",
                "sec_num": null
            },
            {
                "text": "Because the string used to generate a COMBINER step can have length at most 3k + 2, and the resulting step contains an index for each symbol of the string plus two extra indices, the MG k parser has complexity O(n 3k+4 ) with respect to the length of the input. Note that this expression denotes the complexity with respect to n of the MG k parser obtained for a given k: Taking k to be a variable would add an additional O(3 3k ) complexity factor, because the number of different COMBINER steps that can be applied to a given item grows exponentially with k.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Computational Complexity of MG k",
                "sec_num": "7.8"
            },
            {
                "text": "As for previous parsers, we only show here a sketch of the proof that MG k is correct. The detailed proof has been published previously G\u00f3mez-Rodr\u00edguez 2009) .",
                "cite_spans": [
                    {
                        "start": 136,
                        "end": 157,
                        "text": "G\u00f3mez-Rodr\u00edguez 2009)",
                        "ref_id": "BIBREF22"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Correctness for MG k",
                "sec_num": "7.9"
            },
            {
                "text": "Theorem 8 MG k is correct.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Correctness for MG k",
                "sec_num": "7.9"
            },
            {
                "text": "As with WG k , we define the sets of properly formed trees and coherent items for this algorithm. Let T be a dependency tree headed at a node h. We call such a tree a properly formed tree for the algorithm MG k if it satisfies the following.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof 8",
                "sec_num": null
            },
            {
                "text": "h is of the form {h} \u222a",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "1.",
                "sec_num": null
            },
            {
                "text": "([i..j] \\ g p=1 [l p ..r p ]), with 0 \u2264 g \u2264 k. 2.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "1.",
                "sec_num": null
            },
            {
                "text": "There is a binarization of T such that all the nodes in it have gap degree at most k except for its root node, which can have gap degree up to k + 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "1.",
                "sec_num": null
            },
            {
                "text": "The sets of coherent and coherent final items are defined as in previous proofs. Soundness is shown as for previous algorithms, where we show that consequent trees are properly formed by building a binarization for them from the binarizations obtained from antecedent items. This part of the proof involves imposing additional constraints on binarizations, which are useful to provide a suitable way of combining binarizations obtained from antecedents of steps. Completeness is proven by showing the following, stronger claim.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "1.",
                "sec_num": null
            },
            {
                "text": "Let T be a dependency tree headed at node h, and properly formed for MG k . Then, if",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proposition 1",
                "sec_num": null
            },
            {
                "text": "h = {h} \u222a ([i..j] \\ g p=1 [l p ..r p ]), for g \u2264 k, the item [i, j, h, (l 1 , r 1 ), . . . , (l g , r g",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proposition 1",
                "sec_num": null
            },
            {
                "text": ") ] containing T is derivable under this parser. To prove this, we say that a binarization of a properly formed tree is a well-formed binarization for MG k if each of its nodes has gap degree \u2264 k except possibly the head, which can have gap degree k + 1. We then reduce the proof to establishing the following lemma.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proposition 1",
                "sec_num": null
            },
            {
                "text": "Let B be a well-formed binarization of a dependency tree T, headed at a node h and properly formed for MG k . If the projection of h in T is r g ) ] containing T is derivable under this parser. The lemma is shown by strong induction on the number of nodes of B (denoted #B). The base case where #B = 1 is trivial. For the induction step, we consider different cases depending on the number and type of children of the head node h of B. When h has a single child, we obtain the item corresponding to T from a smaller item, shown to be derivable by the induction hypothesis, by using a LINK step. Where h has two children in B, the relevant item is obtained by using a COMBINER step. A structure which is strongly ill-nested for gap degree 1, but only mildly ill-nested for gap degree \u2265 2.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 141,
                        "end": 144,
                        "text": "r g",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Lemma 2",
                "sec_num": null
            },
            {
                "text": "h T = h B = {h} \u222a ([i..j] \\ g p=1 [l p ..r p ]), for g \u2264 k, the item [i, j, h, (l 1 , r 1 ), . . . , (l g ,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 2",
                "sec_num": null
            },
            {
                "text": "The MG k algorithm parses mildly ill-nested structures for gap degree k in polynomial time. The mildly ill-nested structures for gap degree k are those with a binarization of gap degree \u2264 k. Because a binarization of a dependency structure cannot have lower gap degree than the original structure, the mildly ill-nested structures for gap degree k all have gap degree \u2264 k. Given the relation between MG k and WG k , we know they contain all well-nested structures with gap degree \u2264 k. Figure 9 shows a structure with gap degree 1, but which is strongly ill-nested for gap degree 1. For all trees up to 10 nodes (excluding the dummy root node at position 0) all structures of gap degree k with length smaller than 10 are well-nested or only mildly ill-nested for that gap degree. Even if T is strongly ill-nested for a gap degree, there is always an m \u2208 N such that T is mildly ill-nested for m (every structure can be binarized, and binarizations have finite gap degree). For example, the structure in Figure 9 is mildly ill-nested for gap degree 2. Therefore, MG k parsers have the property of being able to parse any arbitrary dependency structure as long as we make k large enough. Structures like the one in Figure 9 do not arise in dependency treebanks. None of the treebanks for nine different languages 10 contain structures that are strongly ill-nested for their gap degree (Table 1) . Therefore, in any of these treebanks, the MG k parser can parse every sentence with gap degree at most k in time O(n 3k+4 ).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 485,
                        "end": 493,
                        "text": "Figure 9",
                        "ref_id": "FIGREF2"
                    },
                    {
                        "start": 1002,
                        "end": 1010,
                        "text": "Figure 9",
                        "ref_id": "FIGREF2"
                    },
                    {
                        "start": 1212,
                        "end": 1220,
                        "text": "Figure 9",
                        "ref_id": "FIGREF2"
                    },
                    {
                        "start": 1382,
                        "end": 1391,
                        "text": "(Table 1)",
                        "ref_id": "TABREF4"
                    }
                ],
                "eq_spans": [],
                "section": "Mildly Ill-Nested Dependency Structures",
                "sec_num": "7.10"
            },
            {
                "text": "Link Grammar (LG), introduced by Temperley (1991, 1993) , is a theory of syntax whose structural representation of sentences is closely related to projective dependency representations, but with some important differences. 11",
                "cite_spans": [
                    {
                        "start": 33,
                        "end": 55,
                        "text": "Temperley (1991, 1993)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Link Grammar Schemata",
                "sec_num": "8."
            },
            {
                "text": "Undirected links: Like dependency formalisms, LG represents the structure of sentences as a set of links between words. However, whereas dependency links are directed, the links used in LG are undirected: There is no distinction made between heads and dependents. Cycles: The sets of links representing the structure of sentences in LG may contain cycles, in contrast to dependency structures.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Link Grammar Schemata",
                "sec_num": "8."
            },
            {
                "text": "LG is a grammar-based formalism in which a grammar G consists of a set of words, each of which is associated with a set of linking requirements. Given a link grammar G, a set of labelled links between the words of a sentence w 1 . . . w n is said to be a linkage for that sentence if it satisfies the following conditions: planarity (the links do not cross when drawn above the words), connectivity (the undirected graph defined by links is connected), and satisfaction (the links satisfy the linking requirements of all the words in the input). An input sentence is considered grammatical with respect to a link grammar G if it is possible to build a linkage for the sentence with the grammar G.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Link Grammar Schemata",
                "sec_num": "8."
            },
            {
                "text": "The linking requirements of a word are expressed as a set of rules specifying the labels of the links that can be established between that word and other words located to its left or to its right. Linking requirements can include constraints on the order of the links, for example, a requirement can specify that a word w can be linked to two words located to its left in such a way that the link to the farthest (leftmost) word has a particular label L 2 and the link to the closest word has a label L 1 .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Link Grammar Schemata",
                "sec_num": "8."
            },
            {
                "text": "We use the disjunctive form notation (Sleator and Temperley 1991) to denote linking requirements: The requirements of words are expressed as a set of disjuncts. Each disjunct corresponds to one way of satisfying the requirements of the word. We represent a disjunct for a word w as a pair of strings \u0394 =",
                "cite_spans": [
                    {
                        "start": 37,
                        "end": 65,
                        "text": "(Sleator and Temperley 1991)",
                        "ref_id": "BIBREF62"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Link Grammar Schemata",
                "sec_num": "8."
            },
            {
                "text": "(R 1 R 2 . . . R q , L 1 L 2 . . . L p ) where L 1 , L 2 , .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Link Grammar Schemata",
                "sec_num": "8."
            },
            {
                "text": ". . L p are the labels of the links that must connect w to words located to the left of w, which must be monotonically increasing in distance from w (e.g., L p links to the leftmost word that is directly linked to w), and R 1 , R 2 , . . . R p are the labels of the links that must connect w to words to its right, also monotonically increasing in distance from w (e.g., R q links to the rightmost word that is directly connected to w).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Link Grammar Schemata",
                "sec_num": "8."
            },
            {
                "text": "Parsing schemata for LG parsers follow the same principles used for constituency and dependency formalisms. Item sets for LG parsing schemata are defined as sets of partial syntactic structures, which in this case are partial linkages:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Link Grammar Schemata",
                "sec_num": "8."
            },
            {
                "text": "Given a link grammar G and a string w 1 . . . w n , a partial linkage is any edge-labeled undirected graph H such that the following conditions hold.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "r The graph H has n vertices {v 1 , . . . , v n }, where each vertex v i is a tuple (w i , i, \u0394 i ) such that \u0394 i is a disjunct for w i in the grammar G.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "r The graph H is connected and satisfies the planarity requirement with respect to the order v 1 , . . . , v n of vertices (i.e., if we draw vertices in that order, with the given links, the links do not cross).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "r Given a vertex v i = (w i , i, \u0394 i ) such that \u0394 i = (R 1 R 2 . . . R q , L 1 L 2 . . . L p )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": ", the following conditions are satisfied:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "- Every edge {v i , v j } with j < i must be labelled L s for some 1 \u2264 s \u2264 p. - For every pair of edges {v i , v j }, {v i , v k } such that k < j < i, we have that {v i , v j } is labelled L s 1 , {v i , v k } is labelled L s 2 , and s 1 < s 2 . - Every edge {v i , v j } with j > i must be labelled R t for some 1 \u2264 t \u2264 q. - For every pair of edges {v i , v j }, {v i , v k } such that k > j > i, we have that {v i , v j } is labelled R t 1 , {v i , v k } is labelled R t 2 , and t 1 < t 2 .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "Informally, a partial linkage is the result of choosing a particular disjunct from those available for each word in the input string, and then adding labelled links between words that are compatible with the requirements of the disjunct. Compatibility means that, for each word w i associated with a disjunct",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "\u0394 i = (R 1 R 2 . . . R q , L 1 L 2 . . . L p )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": ", the list of labels of links connecting v i to words to its right, ordered from the leftmost to the rightmost such word, is of the form",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "R i 1 , R i 2 , . . . R i r , with 0 < i 1 < i 2 < . . . < i r \u2264 q and,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "symmetrically, the list of labels of links connecting v i to words to its left, ordered from the rightmost to the leftmost, is of the form",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "L j 1 , L j 2 , . . . L j l , with 0 < j 1 < j 2 < . . . < j l \u2264 p.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "Given such a linkage, the right linking requirements R i 1 , R i 2 , . . . R i r of the word w i are satisfied, and the same for the left linking requirements L j 1 , L j 2 , . . . L j l of w i . Linking requirements that are not satisfied (e.g., the requirement of a link R k in the disjunct associated with word w i , with 0 < k \u2264 q, such that k / \u2208 {i 1 , . . . , i r }) are said to be unsatisfied. The definition of item sets for LG resembles those for dependency parsers (Definition 4), where items come from a partition of the set of partial linkages for a given link grammar G. With these item sets, LG parsing schemata are analogous to the dependency and constituency cases. As an example of an LG parsing schema, we describe the original LG parser by Sleator and Temperley (1991) , and show how projective parsing schemata, such as those seen in Section 3, can be adapted to obtain new LG parsers.",
                "cite_spans": [
                    {
                        "start": 760,
                        "end": 788,
                        "text": "Sleator and Temperley (1991)",
                        "ref_id": "BIBREF62"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 9",
                "sec_num": null
            },
            {
                "text": "The LG parser of Sleator and Temperley (1991) is a dynamic programming algorithm that builds linkages top-down: A link between v i and v k is always added before links between v i and v j or between v j and v k , if i < j < k. This contrasts with many of the dependency parsers seen in previous sections (Eisner 1996; Eisner and Satta 1999; Yamada and Matsumoto 2003) , which build dependency graphs bottom-up.",
                "cite_spans": [
                    {
                        "start": 17,
                        "end": 45,
                        "text": "Sleator and Temperley (1991)",
                        "ref_id": "BIBREF62"
                    },
                    {
                        "start": 304,
                        "end": 317,
                        "text": "(Eisner 1996;",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 318,
                        "end": 340,
                        "text": "Eisner and Satta 1999;",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 341,
                        "end": 367,
                        "text": "Yamada and Matsumoto 2003)",
                        "ref_id": "BIBREF66"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "Item set: The item set for Sleator and Temperley's parser is B, C] represents the set of partial linkages over the substring w i . . . w j of the input, w i is linked to words in that substring by links labelled \u03b1 and has right linking requirements \u03b2 unsatisfied, w j is linked to words in the substring by links labelled \u03b3 and has left linking requirements \u03b4 unsatisfied, B is True if and only if there is a direct link between w i and w j , and C is True if and only if all the inner words in the span are transitively reflexively linked to one of the end words w i or w j , and have all of their linking requirements satisfied.",
                "cite_spans": [
                    {
                        "start": 61,
                        "end": 66,
                        "text": "B, C]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "I SlT = {[i, j, \u03b1 \u2022 \u03b2, \u03b3 \u2022 \u03b4, B, C] | 0 \u2264 i \u2264 j \u2264 n + 1 \u2227 B, C \u2208 {True, False} and \u03b1, \u03b2, \u03b3, \u03b4 are strings of link labels} where an item [i, j, \u03b1 \u2022 \u03b2, \u03b3 \u2022 \u03b4,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "String positions referenced by the items in I SlT range from 0 to n + 1. Position 0 corresponds to an artificial word w 0 (the wall) that the LG formalism inserts at the beginning of every input sentence (Sleator and Temperley 1991) . Therefore, we assume that strings are extended with this symbol. On the other hand, position n + 1 corresponds to a dummy word w n+1 that must not be linkable to any other, and is used by the parser for convenience, as in the schema for Yamada and Matsumoto's dependency parser (Section 3.4).",
                "cite_spans": [
                    {
                        "start": 204,
                        "end": 232,
                        "text": "(Sleator and Temperley 1991)",
                        "ref_id": "BIBREF62"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "We use the notation [i, \u03b1, \u03b2] as shorthand for the item [i, i, \u2022\u03b1, \u2022\u03b2, False, True] , which is an item used to select a particular disjunct for a word w i .",
                "cite_spans": [
                    {
                        "start": 56,
                        "end": 83,
                        "text": "[i, i, \u2022\u03b1, \u2022\u03b2, False, True]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "Deduction steps: The set of deduction steps is the following:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "SELECTDISJUNCT: [i, R q R q\u22121 . . . R 1 , L p L p\u22121 . . . L 1 ] such that w i has a disjunct \u0394 = (R 1 R 2 . . . R q , L 1 L 2 . . . L p ) INITTER: [0, \u03b1, \u03b3] [n + 1, , ] [0, n + 1, \u2022\u03b1, , False, False] LEFTPREDICT: [i, j, \u03b1 \u2022 \u03b2, \u03b3 \u2022 \u03b4, B 1 , False] [z, \u03c3, \u03c6] [i, z, \u2022\u03b2, \u2022\u03c6, False, (z \u2212 i = 1)] i < z < j LEFTLINKPREDICT (v i \u2190 b \u2212 \u2192 v z ): [i, j, \u03b1 \u2022 b\u03b2, \u03b3 \u2022 \u03b4, B 1 , False] [z, \u03c3, b\u03c6] [i, z, b \u2022 \u03b2, b \u2022 \u03c6, True, (z \u2212 i = 1)] i < z < j RIGHTPREDICT: [i, j, \u03b1 \u2022 \u03b2, \u03b3 \u2022 \u03b4, B 1 , False] [z, \u03c3, \u03c6] [z, j, \u2022\u03c3, \u2022\u03b4, False, (j \u2212 z = 1)] i < z < j RIGHTLINKPREDICT (v z \u2190 b \u2212 \u2192 v j ): [i, j, \u03b1 \u2022 \u03b2, \u03b3 \u2022 b\u03b4, B 1 , False] [z, b\u03c3, \u03c6] [z, j, b \u2022 \u03c3, b \u2022 \u03b4, True, (j \u2212 z = 1)] i < z < j COMPLETER: [i, j, \u03b1 \u2022 \u03b2, \u03b3 \u2022 \u03b4, B 1 , False] [i, z, \u03b2\u2022, \u03c6\u2022, B 2 , True] [z, j, \u03c3\u2022, \u03b4\u2022, B 3 , True] [z, \u03c3, \u03c6] [i, j, \u03b1\u03b2\u2022, \u03b3\u03b4\u2022, B 1 , True] B 2 \u2228 B 3",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "An annotation of the form (",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "v i \u2190 b \u2212 \u2192 v j )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "near the name of a step in this and subsequent LG schemata indicates that the corresponding step adds a link labelled b between nodes v i and v j , and can be used to recover a set of complete linkages contained in a final item from each sequence of deduction steps that generates it. The SELECTDISJUNCT step chooses one of the available disjuncts for a given word w i . The INITTER step starts the top-down process by constructing a linkage that spans the whole string w 1 . . . w n , but where no links have been constructed yet. Then, the PREDICT and LINKPREDICT steps repeatedly divide the problem of finding a linkage for a substring w i . . . w j into the smaller subproblems of finding linkages for w i . . . w z and w z . . . w j , with i < z < j. In particular, the LEFTPREDICT step poses the subproblem of finding a linkage for w i . . . w z in which w i is not directly linked to w z , and LEFTLINKPREDICT poses the same problem while building a direct link from w i to w z . RIGHTPREDICT and RIGHTLINKPREDICT proceed analogously for the substring w z . . . w j . After these two smaller linkages have been found, they are combined by a COMPLETER step into a larger linkage; the flags b and c in items are used by the COMPLETER step to ensure that its resulting item will contain a valid linkage satisfying the connectivity constraint. An example of this process, where a particular substring is parsed by using the LEFTLINKPREDICT and RIGHTPREDICT steps to divide it into smaller substrings, is shown in Figure 10 . The algorithm runs in time O(n 3 ) with respect to the length of the input, because none of its deduction steps uses more than three independent string position indices. Final items: The set of final items is",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 1516,
                        "end": 1525,
                        "text": "Figure 10",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "{[0, n + 1, \u03b1\u2022, \u03b2\u2022, B, True]}.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "Items of this form contain full valid linkages for the string w 0 . . . w n , because having the second boolean flag set to True implies that their linkages for w 0 . . . w n+1 have at most two connected components, and we have assumed that the word w n+1 cannot be linked to any other, so one of the components must link w 0 . . . w n .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sleator and Temperley's LG Parser",
                "sec_num": "8.1"
            },
            {
                "text": "We now exploit similarities between LG linkages and projective dependency structures to adapt projective dependency parsers to the LG formalism. As an example we present an LG version of the parser by Eisner (1996) , but the same principles can be applied to other parsers: schemata for LG versions of the parsers by Eisner and Satta (1999) and Yamada and Matsumoto (2003) can be found in G\u00f3mez-Rodr\u00edguez (2009) .",
                "cite_spans": [
                    {
                        "start": 201,
                        "end": 214,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 317,
                        "end": 340,
                        "text": "Eisner and Satta (1999)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 345,
                        "end": 372,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    },
                    {
                        "start": 389,
                        "end": 411,
                        "text": "G\u00f3mez-Rodr\u00edguez (2009)",
                        "ref_id": "BIBREF22"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Adapting Projective Dependency Parsers to Link Grammar",
                "sec_num": "8.2"
            },
            {
                "text": "Item sets from dependency parsers are adapted to LG parsers by considering the forests contained in each dependency item. The corresponding LG items contain linkages with the same structure as these forests. For example, because each forest in an item of the form [i, j, False, False] in Eisner's dependency parsing schema contains two trees",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Adapting Projective Dependency Parsers to Link Grammar",
                "sec_num": "8.2"
            },
            {
                "text": "An example of LG parsing with the schema for Sleator and Temperley's parser. headed at the words w i and w j , the analogous item in the corresponding LG parsing schema will contain linkages with two connected components, one containing the word w i and the other containing w j . The notion of a head is lost in the conversion because the undirected LG linkages do not make distinctions between heads and dependents. This simplifies the notation used to denote items in some cases: For instance, we do not need to make a distinction between Eisner items of the form [i, j, True, False] and those of the form [i, j, False, True] , because their structure is the same other than the direction of the links. Therefore, items in the LG version of Eisner's parser will use a single flag, indicating whether linkages contained in them have one or two connected components.",
                "cite_spans": [
                    {
                        "start": 567,
                        "end": 586,
                        "text": "[i, j, True, False]",
                        "ref_id": null
                    },
                    {
                        "start": 609,
                        "end": 628,
                        "text": "[i, j, False, True]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "The combining and linking steps of the dependency parsers are directly translated to LG. If the original dependency steps always produce items containing projective dependency forests, the resulting LG steps produce items with planar linkages. When the original dependency steps have constraints related to the position of the head in items (like combiner steps in Eisner's parser, where we can combine [i, j, True, False] with [ j, k, True, False] but not with [j, k, False, True] ), we ignore these constraints, allowing any word in a linkage to be its \"head\" for the purpose of linking it to other linkages.",
                "cite_spans": [
                    {
                        "start": 403,
                        "end": 422,
                        "text": "[i, j, True, False]",
                        "ref_id": null
                    },
                    {
                        "start": 428,
                        "end": 448,
                        "text": "[ j, k, True, False]",
                        "ref_id": null
                    },
                    {
                        "start": 462,
                        "end": 481,
                        "text": "[j, k, False, True]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "Because projective dependency parsers do not allow cyclic structures, we add steps or remove constraints to allow cycles, so that the parsers are able to link two words that are already in the same connected component of a linkage. In the schema obtained from Eisner's parser, this is done by allowing LINK steps to be applied to items representing fully connected linkages; in the schema corresponding to Eisner and Satta's parser we allow COMBINER steps to create a link in addition to joining two linkages; and in the schema for Yamada and Matsumoto's parser we add a step that creates two links at the same time, combining the functionality of the L-LINK and R-LINK steps.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "Finally, because LG is a grammar-based formalism where the set of valid linkages is constrained by disjuncts associated with words, we include disjunct information in items in order to ensure that only grammatical linkages are constructed. This is similar to the schema for Sleator and Temperley's parser, but in this case items need to specify both left and right linking requirements for each of their end words: These bottomup parsers establish links from end words of an item to words outside the item's span (which can be to the left or to the right of the span) rather than to words inside the span (which are always to the right of the left end word, and to the left of the right end word).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "Based on this, the following is an LG variant of the projective dependency parser of Eisner (1996) . Item set: The item set is",
                "cite_spans": [
                    {
                        "start": 85,
                        "end": 98,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "I EisLG = {[i, j, \u03b1 1 \u2022 \u03b2 1 , \u03b1 2 \u2022 \u03b2 2 , \u03b1 3 , \u03b1 4 , B] | 0 \u2264 i \u2264 j \u2264 n B",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "\u2208 {True, False} and \u03b1 1 , \u03b2 1 , \u03b1 2 , \u03b2 2 , \u03b1 3 , \u03b1 4 are strings of link labels} where an item of the form [i, j, \u03b1 1 \u2022 \u03b2 1 , \u03b1 2 \u2022 \u03b2 2 , \u03b1 3 , \u03b1 4 , B] represents the set of partial linkages over the substring w i . . . w j of the input, satisfying the following conditions.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "r All words in positions k, such that i < k < j, have all linking requirements satisfied.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "r The word in position i has left linking requirements \u03b1 3 not satisfied, and right linking requirements \u03b1 1 \u03b2 1 , where the requirements \u03b1 1 are satisfied by links to words within the item's span, and the requirements \u03b2 1 are not satisfied. Requirements appear in \u03b1 3 and \u03b1 1 \u03b2 1 in increasing order of link distance.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "r The word in position j has right linking requirements \u03b1 4 not satisfied, and left linking requirements \u03b1 2 \u03b2 2 , where the requirements \u03b1 2 are satisfied by links to words within the item's span, and the requirements \u03b2 2 are not satisfied. Requirements appear in \u03b1 4 and \u03b1 2 \u03b2 2 in increasing order of link distance.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "r The partial linkage is connected if B equals True, or has exactly two connected components (one containing the node v i and the other containing v j ) if B equals False.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "Deduction steps: The set of deduction steps for this parser is as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "INITTER: [i, i + 1, \u03b1 R , \u03b2 L , \u03b1 L , \u03b2 R , False] 0 \u2264 i \u2264 n \u2212 1 such that w i has a disjunct \u0394 i = (\u03b1 R , \u03b1 L ) and w i+1 has a disjunct \u0394 i+1 = (\u03b2 R , \u03b2 L ). LINK (v i \u2190 b \u2212 \u2192 v j ): [i, j, \u03b1 1 \u2022 b\u03b2 1 , \u03b1 2 \u2022 b\u03b2 2 , \u03b1 3 , \u03b1 4 , B] [i, j, \u03b1 1 b \u2022 \u03b2 1 , \u03b1 2 b \u2022 \u03b2 2 , \u03b1 3 , \u03b1 4 , True] COMBINE: [i, j, \u03b1 1 \u2022 \u03b2 1 , \u03b1 2 \u2022, \u03b1 3 , \u03b1 4 , B 1 ] [ j, k, \u03b1 4 \u2022, \u03b3 2 \u2022 \u03b4 2 , \u03b1 2 , \u03b4 4 , B 2 ] [i, k, \u03b1 1 \u2022 \u03b2 1 , \u03b3 2 \u2022 \u03b4 2 , \u03b1 3 , \u03b4 4 , B 1 \u2227 B 2 ] B 1 \u2228 B 2",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "These steps resemble those in the schema for Eisner's dependency parser, with the exception that the LINK step is able to build links on items that contain fully connected linkages (equivalent to the [i, j, True, False] and [i, j, False, True] items of the dependency parser). A version of the parser restricted to acyclic linkages can be obtained by adding the constraint that B must equal False in the LINK step.",
                "cite_spans": [
                    {
                        "start": 200,
                        "end": 219,
                        "text": "[i, j, True, False]",
                        "ref_id": null
                    },
                    {
                        "start": 224,
                        "end": 243,
                        "text": "[i, j, False, True]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "Final items: The set of final items is {[0, n, \u03b1\u2022, \u03b2\u2022, , , True]}, corresponding to the set of items containing fully connected linkages for the whole input string.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "LG parsing schemata based on the parsers of Eisner and Satta (1999) and Yamada and Matsumoto (2003) are not shown here for space reasons, but are presented by G\u00f3mez-Rodr\u00edguez (2009) . The relationships between these three LG parsing schemata are the same as the corresponding dependency parsing schemata, that is, the LG variants of Eisner and Satta's and Yamada and Matsumoto's dependency parsers are step contractions of the LG variant of Eisner's parser. As with the algorithm of Sleator and Temperley, these bottom-up LG parsers run in cubic time with respect to input length.",
                "cite_spans": [
                    {
                        "start": 44,
                        "end": 67,
                        "text": "Eisner and Satta (1999)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 72,
                        "end": 99,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    },
                    {
                        "start": 159,
                        "end": 181,
                        "text": "G\u00f3mez-Rodr\u00edguez (2009)",
                        "ref_id": "BIBREF22"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 10",
                "sec_num": null
            },
            {
                "text": "The parsing schemata formalism of Sikkel (1997) has previously been used to define, analyze, and compare algorithms for constituency-based parsing. We have shown how to extend the formalism to dependency parsers, as well as the related Link Grammar formalism.",
                "cite_spans": [
                    {
                        "start": 34,
                        "end": 47,
                        "text": "Sikkel (1997)",
                        "ref_id": "BIBREF61"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions and Future Work",
                "sec_num": "9."
            },
            {
                "text": "Deductive approaches have been used in the past to describe individual dependency parsers: In Kuhlmann (2007 Kuhlmann ( , 2010 ) a grammatical deduction system was used to define a parser for regular dependency grammars.",
                "cite_spans": [
                    {
                        "start": 94,
                        "end": 108,
                        "text": "Kuhlmann (2007",
                        "ref_id": "BIBREF39"
                    },
                    {
                        "start": 109,
                        "end": 126,
                        "text": "Kuhlmann ( , 2010",
                        "ref_id": "BIBREF38"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions and Future Work",
                "sec_num": "9."
            },
            {
                "text": "McDonald and Nivre (2007) give an alternative framework for dependency parsers, viewing them as transition systems. That model is based on parser configurations and transitions, and has no clear relationship to the approach described here.",
                "cite_spans": [
                    {
                        "start": 13,
                        "end": 25,
                        "text": "Nivre (2007)",
                        "ref_id": "BIBREF49"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions and Future Work",
                "sec_num": "9."
            },
            {
                "text": "To demonstrate the theoretical uses of dependency parsing schemata, we have used them to describe a wide range of existing projective and non-projective dependency parsers. We have also clarified various relations between parsers which were originally formulated very differently-for example, establishing the relation between the dynamic programming algorithm of Eisner (1996) and the transition-based parser of Yamada and Matsumoto (2003) . We have also used the parsing schemata framework as a formal tool to verify the correctness of parsing algorithms.",
                "cite_spans": [
                    {
                        "start": 364,
                        "end": 377,
                        "text": "Eisner (1996)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 413,
                        "end": 440,
                        "text": "Yamada and Matsumoto (2003)",
                        "ref_id": "BIBREF66"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions and Future Work",
                "sec_num": "9."
            },
            {
                "text": "Not only are dependency parsing schemata useful when describing and extending existing parsing algorithms, they can be used to define new parsers. We have presented an algorithm that can parse any well-nested dependency structure with gap degree bounded by a constant k with time complexity O(n 2k+5 ), and additionally, have defined a wider set of structures that we call mildly ill-nested for a given gap degree k, and presented an algorithm that can parse these in time O(n 3k+4 ). The practical relevance of this set of structures can be seen in the data obtained from several dependency treebanks, showing that all the sentences contained in them are mildly ill-nested for their gap degree, and thus they are parsable with this algorithm. The strategy used by this algorithm for parsing mildly ill-nested structures has been adapted to solve the problem of finding minimal fan-out binarizations of LCFRS to improve parsing efficiency (see ).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions and Future Work",
                "sec_num": "9."
            },
            {
                "text": "An interesting line of future work would be to provide implementations of the mildly non-projective dependency parsers presented here, using probabilistic models to guide their linking decisions, and compare their practical performance and accuracy to those of other non-projective dependency parsers. Additionally, our definition of mildly ill-nested structures is closely related to the way the corresponding parser works. It would be interesting to find a more grammar-oriented definition that would provide linguistic insight into this set of structures.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions and Future Work",
                "sec_num": "9."
            },
            {
                "text": "An alternative generalization of the concept of well-nestedness has recently been introduced by Maier and Lichte (2011). The definition of this property of structures, called k-ill-nestedness, is more declarative than that of mildly ill-nestedness. However, it is based on properties that are not local to projections or subtrees, and there is no evidence that k-ill-nested structures are parsable in polynomial time.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions and Future Work",
                "sec_num": "9."
            },
            {
                "text": "Finally, we observe that that some well-known parsing algorithms discussed here (Nivre 2003; ) rely on statistically-driven control mechanisms that fall below the abstraction level of parsing schemata. Therefore, it would be useful to have an extension of parsing schemata allowing the description and comparison of these control structures in a general way.",
                "cite_spans": [
                    {
                        "start": 80,
                        "end": 92,
                        "text": "(Nivre 2003;",
                        "ref_id": "BIBREF48"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions and Future Work",
                "sec_num": "9."
            },
            {
                "text": "Note that the trees in a dependency forest can have different yields, because the node set of a dependency tree for a string w 1 . . . w n can be any subset of [1..n]. In fact, all the forests used by the parsers in this article contain trees with non-overlapping yields, although this is not required by the definition.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "Coherent (final) items are called correct (final) items in the original formulation bySikkel (1997). 3 Derivable items are called valid items in the original formulation bySikkel (1997).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "Although in the parsers described in Section 7 we use a different notation for the hypotheses, they still are the same, as explained later.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "For this and the rest of the complexity results in this article, we assume that the linking decision associated with a D-rule can be made in constant time.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "We could have used items [i, i + 1, False, False] as hypotheses for this parsing schema, and not require an Initter step, but we prefer a standard set of hypotheses valid for all parsers as it facilitates more straightforward proofs of the relations between schemata.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "A CFG-like rule A(\u03b1 * \u03b2) rewrites a preterminal A to strings \u03b1x\u03b2 over terminals and preterminals, where \u03b1, \u03b2 are strings of preterminals and x is a terminal of category A (the head of the rule). A special rule * (S) is used to state that the preterminal S can act as the root of an extended dependency tree.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "Removing a subtree from a dependency tree involves removing all the nodes in the subtree from its vertex set, and all the outgoing links from nodes in the subtree from its edge set.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "Although standard TAG parsing algorithms run in time O(n 6 ) with respect to the input length, they also have a complexity factor related to grammar size.Eisner and Satta (2000) show that, in the case of lexicalized TAG, this factor is a function of the input length n; hence the additional complexity.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "Arabic(Haji\u010d et al. 2004), Czech(Haji\u010d et al. 2006), Danish(Kromann 2003), Dutch(van der Beek et al. 2002), Latin (Bamman and Crane 2006), Portuguese(Afonso et al. 2002), Slovene(D\u017eeroski et al. 2006), Swedish(Nilsson, Hall, and Nivre 2005), and Turkish (Atalay,Oflazer, and Say 2003;Oflazer et al. 2003). 11 A complete treatment of LG is beyond the scope of this article:Schneider (1998) gives a detailed comparison of Link Grammar and dependency formalisms.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            }
        ],
        "back_matter": [],
        "bib_entries": {
            "BIBREF0": {
                "ref_id": "b0",
                "title": "Floresta sint\u00e1(c)tica\": A treebank for Portuguese",
                "authors": [
                    {
                        "first": "Susana",
                        "middle": [],
                        "last": "Afonso",
                        "suffix": ""
                    },
                    {
                        "first": "Eckhard",
                        "middle": [],
                        "last": "Bick",
                        "suffix": ""
                    },
                    {
                        "first": "Renato",
                        "middle": [],
                        "last": "Haber",
                        "suffix": ""
                    },
                    {
                        "first": "Diana",
                        "middle": [],
                        "last": "Santos",
                        "suffix": ""
                    }
                ],
                "year": 2002,
                "venue": "Proceedings of the 3rd International Conference on Language Resources and Evaluation (LREC 2002)",
                "volume": "",
                "issue": "",
                "pages": "1968--1703",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Afonso, Susana, Eckhard Bick, Renato Haber, and Diana Santos. 2002. \"Floresta sint\u00e1(c)tica\": A treebank for Portuguese. In Proceedings of the 3rd International Conference on Language Resources and Evaluation (LREC 2002), pages 1968-1703, Las Palmas.",
                "links": null
            },
            "BIBREF1": {
                "ref_id": "b1",
                "title": "Kemal Oflazer, and Bilge Say. 2003. The annotation process in the Turkish treebank",
                "authors": [
                    {
                        "first": "Miguel",
                        "middle": [
                            "A"
                        ],
                        "last": "Alonso",
                        "suffix": ""
                    },
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Cabrero",
                        "suffix": ""
                    }
                ],
                "year": 1999,
                "venue": "Proceedings of the Ninth Conference of the European Chapter of the Association for Computational Linguistics (EACL-99)",
                "volume": "",
                "issue": "",
                "pages": "243--246",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Alonso, Miguel A., David Cabrero,\u00c9ric Villemonte de la Clergerie, and Manuel Vilares. 1999. Tabular algorithms for TAG parsing. In Proceedings of the Ninth Conference of the European Chapter of the Association for Computational Linguistics (EACL-99), pages 150-157, Bergen. Atalay, Nart B., Kemal Oflazer, and Bilge Say. 2003. The annotation process in the Turkish treebank. In Proceedings of EACL Workshop on Linguistically Interpreted Corpora (LINC-03), pages 243-246, Budapest.",
                "links": null
            },
            "BIBREF2": {
                "ref_id": "b2",
                "title": "The Alpino dependency treebank. In Language and Computers, Computational Linguistics in the Netherlands",
                "authors": [
                    {
                        "first": "Giuseppe",
                        "middle": [
                            ";"
                        ],
                        "last": "Attardi",
                        "suffix": ""
                    },
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Bamman",
                        "suffix": ""
                    },
                    {
                        "first": "Gregory",
                        "middle": [],
                        "last": "Crane ; Prague",
                        "suffix": ""
                    },
                    {
                        "first": "Cristina",
                        "middle": [],
                        "last": "Barbero",
                        "suffix": ""
                    },
                    {
                        "first": "Leonardo",
                        "middle": [],
                        "last": "Lesmo",
                        "suffix": ""
                    },
                    {
                        "first": "Vincenzo",
                        "middle": [],
                        "last": "Lombardo",
                        "suffix": ""
                    },
                    {
                        "first": "Paola",
                        "middle": [],
                        "last": "Merlo",
                        "suffix": ""
                    },
                    {
                        "first": ";",
                        "middle": [],
                        "last": "Leonoor",
                        "suffix": ""
                    },
                    {
                        "first": "Gosse",
                        "middle": [],
                        "last": "Bouma",
                        "suffix": ""
                    },
                    {
                        "first": "Robert",
                        "middle": [],
                        "last": "Malouf",
                        "suffix": ""
                    },
                    {
                        "first": "Gertjan",
                        "middle": [],
                        "last": "Van Noord",
                        "suffix": ""
                    }
                ],
                "year": 1998,
                "venue": "Proceedings of the 10th Conference on Computational Natural Language Learning (CoNLL-X)",
                "volume": "",
                "issue": "",
                "pages": "8--22",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Attardi, Giuseppe. 2006. Experiments with a multilanguage non-projective dependency parser. In Proceedings of the 10th Conference on Computational Natural Language Learning (CoNLL-X), pages 166-170, New York, NY. Bamman, David and Gregory Crane. 2006. The design and use of a Latin dependency treebank. In Proceedings of the Fifth Workshop on Treebanks and Linguistic Theories (TLT 2006), pages 67-78, Prague. Barbero, Cristina, Leonardo Lesmo, Vincenzo Lombardo, and Paola Merlo. 1998. Integration of syntactic and lexical information in a hierarchical dependency grammar. In Proceedings of COLING-ACL '98 Workshop on Processing of Dependency-Based Grammars, pages 58-67, Montreal. van der Beek, Leonoor, Gosse Bouma, Robert Malouf, and Gertjan van Noord. 2002. The Alpino dependency treebank. In Language and Computers, Computational Linguistics in the Netherlands 2001. Selected Papers from the Twelfth CLIN Meeting, pages 8-22, Amsterdam.",
                "links": null
            },
            "BIBREF3": {
                "ref_id": "b3",
                "title": "The structure of shared forests in ambiguous parsing",
                "authors": [
                    {
                        "first": "Sylvie",
                        "middle": [],
                        "last": "Billot",
                        "suffix": ""
                    },
                    {
                        "first": "Bernard",
                        "middle": [],
                        "last": "Lang",
                        "suffix": ""
                    }
                ],
                "year": 1989,
                "venue": "Proceedings of the 27th Annual Meeting of the Association for Computational Linguistics (ACL'89)",
                "volume": "",
                "issue": "",
                "pages": "143--151",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Billot, Sylvie and Bernard Lang. 1989. The structure of shared forests in ambiguous parsing. In Proceedings of the 27th Annual Meeting of the Association for Computational Linguistics (ACL'89), pages 143-151, Montreal.",
                "links": null
            },
            "BIBREF4": {
                "ref_id": "b4",
                "title": "Well-nested drawings as models of syntactic structure (extended version)",
                "authors": [
                    {
                        "first": "Manuel",
                        "middle": [],
                        "last": "Bodirsky",
                        "suffix": ""
                    },
                    {
                        "first": "Marco",
                        "middle": [],
                        "last": "Kuhlmann",
                        "suffix": ""
                    },
                    {
                        "first": "Mathias",
                        "middle": [],
                        "last": "M\u00f6hl",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Bodirsky, Manuel, Marco Kuhlmann, and Mathias M\u00f6hl. 2005. Well-nested drawings as models of syntactic structure (extended version). Technical report, Saarland University.",
                "links": null
            },
            "BIBREF5": {
                "ref_id": "b5",
                "title": "A cascaded syntactic and semantic dependency parsing system",
                "authors": [
                    {
                        "first": "Wanxiang",
                        "middle": [],
                        "last": "Che",
                        "suffix": ""
                    },
                    {
                        "first": "Zhenghua",
                        "middle": [],
                        "last": "Li",
                        "suffix": ""
                    },
                    {
                        "first": "Yuxuan",
                        "middle": [],
                        "last": "Hu",
                        "suffix": ""
                    },
                    {
                        "first": "Yongqiang",
                        "middle": [],
                        "last": "Li",
                        "suffix": ""
                    },
                    {
                        "first": "Bing",
                        "middle": [],
                        "last": "Qin",
                        "suffix": ""
                    },
                    {
                        "first": "Ting",
                        "middle": [],
                        "last": "Liu",
                        "suffix": ""
                    },
                    {
                        "first": "Sheng",
                        "middle": [],
                        "last": "Li",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "Proceedings of the 12th Conference on Computational Natural Language Learning",
                "volume": "",
                "issue": "",
                "pages": "238--242",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Che, Wanxiang, Zhenghua Li, Yuxuan Hu, Yongqiang Li, Bing Qin, Ting Liu, and Sheng Li. 2008. A cascaded syntactic and semantic dependency parsing system. In Proceedings of the 12th Conference on Computational Natural Language Learning (CoNLL 2008), pages 238-242, Manchester.",
                "links": null
            },
            "BIBREF6": {
                "ref_id": "b6",
                "title": "A new statistical parser based on bigram lexical dependencies",
                "authors": [
                    {
                        "first": "Michael",
                        "middle": [],
                        "last": "Collins",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "John",
                        "suffix": ""
                    }
                ],
                "year": 1996,
                "venue": "Proceedings of the 34th Annual Meeting of the Association for Computational Linguistics (ACL'96)",
                "volume": "",
                "issue": "",
                "pages": "184--191",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Collins, Michael John. 1996. A new statistical parser based on bigram lexical dependencies. In Proceedings of the 34th Annual Meeting of the Association for Computational Linguistics (ACL'96), pages 184-191, Santa Cruz, CA.",
                "links": null
            },
            "BIBREF7": {
                "ref_id": "b7",
                "title": "Multilingual dependency parsing using Bayes Point Machines",
                "authors": [
                    {
                        "first": "",
                        "middle": [],
                        "last": "Corston-Oliver",
                        "suffix": ""
                    },
                    {
                        "first": "Anthony",
                        "middle": [],
                        "last": "Simon",
                        "suffix": ""
                    },
                    {
                        "first": "Kevin",
                        "middle": [],
                        "last": "Aue",
                        "suffix": ""
                    },
                    {
                        "first": "Eric",
                        "middle": [],
                        "last": "Duh",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Ringger",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "Proceedings of the Human Language Technology Conference of the North American Chapter of the Association for Computational Linguistics (NAACL HLT 2006)",
                "volume": "",
                "issue": "",
                "pages": "160--167",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Corston-Oliver, Simon, Anthony Aue, Kevin Duh, and Eric Ringger. 2006. Multilingual dependency parsing using Bayes Point Machines. In Proceedings of the Human Language Technology Conference of the North American Chapter of the Association for Computational Linguistics (NAACL HLT 2006), pages 160-167, New York, NY.",
                "links": null
            },
            "BIBREF8": {
                "ref_id": "b8",
                "title": "Parsing with dependency relations and robust parsing",
                "authors": [
                    {
                        "first": "Jacques",
                        "middle": [],
                        "last": "Courtin",
                        "suffix": ""
                    },
                    {
                        "first": "Damien",
                        "middle": [],
                        "last": "Genthial",
                        "suffix": ""
                    }
                ],
                "year": 1998,
                "venue": "Proceedings of COLING-ACL '98 Workshop on Processing of Dependency-Based Grammars",
                "volume": "",
                "issue": "",
                "pages": "88--94",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Courtin, Jacques and Damien Genthial. 1998. Parsing with dependency relations and robust parsing. In Proceedings of COLING-ACL '98 Workshop on Processing of Dependency-Based Grammars, pages 88-94, Montreal.",
                "links": null
            },
            "BIBREF9": {
                "ref_id": "b9",
                "title": "A dependency parser for variable-word-order languages",
                "authors": [
                    {
                        "first": "Michael",
                        "middle": [
                            "A"
                        ],
                        "last": "Covington",
                        "suffix": ""
                    }
                ],
                "year": 1990,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Covington, Michael A. 1990. A dependency parser for variable-word-order languages. Technical Report AI-1990-01, University of Georgia, Athens, GA.",
                "links": null
            },
            "BIBREF10": {
                "ref_id": "b10",
                "title": "A fundamental algorithm for dependency parsing",
                "authors": [
                    {
                        "first": "Michael",
                        "middle": [
                            "A"
                        ],
                        "last": "Covington",
                        "suffix": ""
                    }
                ],
                "year": 2001,
                "venue": "Proceedings of the 39th Annual ACM Southeast Conference",
                "volume": "",
                "issue": "",
                "pages": "95--102",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Covington, Michael A. 2001. A fundamental algorithm for dependency parsing. In Proceedings of the 39th Annual ACM Southeast Conference, pages 95-102, Athens, GA.",
                "links": null
            },
            "BIBREF11": {
                "ref_id": "b11",
                "title": "Question answering passage retrieval using dependency relations",
                "authors": [
                    {
                        "first": "Hang",
                        "middle": [],
                        "last": "Cui",
                        "suffix": ""
                    },
                    {
                        "first": "Renxu",
                        "middle": [],
                        "last": "Sun",
                        "suffix": ""
                    },
                    {
                        "first": "Keya",
                        "middle": [],
                        "last": "Li",
                        "suffix": ""
                    },
                    {
                        "first": "Min-Yen",
                        "middle": [],
                        "last": "Kan",
                        "suffix": ""
                    },
                    {
                        "first": "Tat-Seng",
                        "middle": [],
                        "last": "Chua",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "SIGIR '05: Proceedings of the 28th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval",
                "volume": "",
                "issue": "",
                "pages": "400--407",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Cui, Hang, Renxu Sun, Keya Li, Min-Yen Kan, and Tat-Seng Chua. 2005. Question answering passage retrieval using dependency relations. In SIGIR '05: Proceedings of the 28th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval, pages 400-407, Salvador.",
                "links": null
            },
            "BIBREF12": {
                "ref_id": "b12",
                "title": "Dependency tree kernels for relation extraction",
                "authors": [
                    {
                        "first": "Aron",
                        "middle": [],
                        "last": "Culotta",
                        "suffix": ""
                    },
                    {
                        "first": "Jeffrey",
                        "middle": [],
                        "last": "Sorensen",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "ACL '04: Proceedings of the 42nd Annual Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "423--429",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Culotta, Aron and Jeffrey Sorensen. 2004. Dependency tree kernels for relation extraction. In ACL '04: Proceedings of the 42nd Annual Meeting of the Association for Computational Linguistics, pages 423-429, Barcelona.",
                "links": null
            },
            "BIBREF13": {
                "ref_id": "b13",
                "title": "Machine translation using probabilistic synchronous dependency insertion grammars",
                "authors": [
                    {
                        "first": "Yuan",
                        "middle": [],
                        "last": "Ding",
                        "suffix": ""
                    },
                    {
                        "first": "Martha",
                        "middle": [],
                        "last": "Palmer",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "ACL '05: Proceedings of the 43rd Annual Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "541--548",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ding, Yuan and Martha Palmer. 2005. Machine translation using probabilistic synchronous dependency insertion grammars. In ACL '05: Proceedings of the 43rd Annual Meeting of the Association for Computational Linguistics, pages 541-548, Ann Arbor, MI.",
                "links": null
            },
            "BIBREF14": {
                "ref_id": "b14",
                "title": "Petr Pajas, Zden\u011b\u01e9 Zabokrtsk\u00fd, and Andreja\u017dele",
                "authors": [
                    {
                        "first": "Sa\u0161o",
                        "middle": [],
                        "last": "D\u017eeroski",
                        "suffix": ""
                    },
                    {
                        "first": "Toma\u017e",
                        "middle": [],
                        "last": "Erjavec",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "Proceedings of the 5th International Conference on Language Resources and Evaluation (LREC 2006)",
                "volume": "",
                "issue": "",
                "pages": "1388--1391",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "D\u017eeroski, Sa\u0161o, Toma\u017e Erjavec, Nina Ledinek, Petr Pajas, Zden\u011b\u01e9 Zabokrtsk\u00fd, and Andreja\u017dele. 2006. Towards a Slovene dependency treebank. In Proceedings of the 5th International Conference on Language Resources and Evaluation (LREC 2006), pages 1388-1391, Genoa.",
                "links": null
            },
            "BIBREF15": {
                "ref_id": "b15",
                "title": "An efficient context-free parsing algorithm",
                "authors": [
                    {
                        "first": "Jay",
                        "middle": [],
                        "last": "Earley",
                        "suffix": ""
                    }
                ],
                "year": 1970,
                "venue": "Communications of the ACM",
                "volume": "13",
                "issue": "2",
                "pages": "94--102",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Earley, Jay. 1970. An efficient context-free parsing algorithm. Communications of the ACM, 13(2):94-102.",
                "links": null
            },
            "BIBREF16": {
                "ref_id": "b16",
                "title": "Three new probabilistic models for dependency parsing: An exploration",
                "authors": [
                    {
                        "first": "Jason",
                        "middle": [],
                        "last": "Eisner",
                        "suffix": ""
                    }
                ],
                "year": 1996,
                "venue": "Proceedings of the 16th International Conference on Computational Linguistics (COLING-96)",
                "volume": "",
                "issue": "",
                "pages": "340--345",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Eisner, Jason. 1996. Three new probabilistic models for dependency parsing: An exploration. In Proceedings of the 16th International Conference on Computational Linguistics (COLING-96), pages 340-345, Copenhagen.",
                "links": null
            },
            "BIBREF17": {
                "ref_id": "b17",
                "title": "Compiling comp ling: Weighted dynamic programming and the Dyna language",
                "authors": [
                    {
                        "first": "Jason",
                        "middle": [],
                        "last": "Eisner",
                        "suffix": ""
                    },
                    {
                        "first": "Eric",
                        "middle": [],
                        "last": "Goldlust",
                        "suffix": ""
                    },
                    {
                        "first": "Noah",
                        "middle": [
                            "A"
                        ],
                        "last": "Smith",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "Proceedings of Human Language Technology Conference and Conference on Empirical Methods in Natural Language Processing (HLT-EMNLP 2005)",
                "volume": "",
                "issue": "",
                "pages": "281--290",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Eisner, Jason, Eric Goldlust, and Noah A. Smith. 2005. Compiling comp ling: Weighted dynamic programming and the Dyna language. In Proceedings of Human Language Technology Conference and Conference on Empirical Methods in Natural Language Processing (HLT-EMNLP 2005), pages 281-290, Vancouver.",
                "links": null
            },
            "BIBREF18": {
                "ref_id": "b18",
                "title": "Efficient parsing for bilexical context-free grammars and head automaton grammars",
                "authors": [
                    {
                        "first": "Jason",
                        "middle": [],
                        "last": "Eisner",
                        "suffix": ""
                    },
                    {
                        "first": "Giorgio",
                        "middle": [],
                        "last": "Satta",
                        "suffix": ""
                    }
                ],
                "year": 1999,
                "venue": "Proceedings of the 37th Annual Meeting of the Association for Computational Linguistics (ACL'99)",
                "volume": "",
                "issue": "",
                "pages": "457--464",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Eisner, Jason and Giorgio Satta. 1999. Efficient parsing for bilexical context-free grammars and head automaton grammars. In Proceedings of the 37th Annual Meeting of the Association for Computational Linguistics (ACL'99), pages 457-464, College Park, MD.",
                "links": null
            },
            "BIBREF19": {
                "ref_id": "b19",
                "title": "A faster parsing algorithm for lexicalized tree-adjoining grammars",
                "authors": [
                    {
                        "first": "Jason",
                        "middle": [],
                        "last": "Eisner",
                        "suffix": ""
                    },
                    {
                        "first": "Giorgio",
                        "middle": [],
                        "last": "Satta",
                        "suffix": ""
                    }
                ],
                "year": 2000,
                "venue": "Proceedings of the 5th Workshop on Tree-Adjoining Grammars and Related Formalisms (TAG+5)",
                "volume": "",
                "issue": "",
                "pages": "14--19",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Eisner, Jason and Giorgio Satta. 2000. A faster parsing algorithm for lexicalized tree-adjoining grammars. In Proceedings of the 5th Workshop on Tree-Adjoining Grammars and Related Formalisms (TAG+5), pages 14-19, Paris.",
                "links": null
            },
            "BIBREF20": {
                "ref_id": "b20",
                "title": "RelEx-Relation extraction using dependency parse trees",
                "authors": [
                    {
                        "first": "Katrin",
                        "middle": [],
                        "last": "Fundel",
                        "suffix": ""
                    },
                    {
                        "first": "Robert",
                        "middle": [],
                        "last": "K\u00fcffner",
                        "suffix": ""
                    },
                    {
                        "first": "Ralf",
                        "middle": [],
                        "last": "Zimmer",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "Bioinformatics",
                "volume": "23",
                "issue": "3",
                "pages": "365--371",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Fundel, Katrin, Robert K\u00fcffner, and Ralf Zimmer. 2006. RelEx-Relation extraction using dependency parse trees. Bioinformatics, 23(3):365-371.",
                "links": null
            },
            "BIBREF21": {
                "ref_id": "b21",
                "title": "Dependency systems and phrase-structure systems",
                "authors": [
                    {
                        "first": "Haim",
                        "middle": [],
                        "last": "Gaifman",
                        "suffix": ""
                    }
                ],
                "year": 1965,
                "venue": "Information and Control",
                "volume": "8",
                "issue": "",
                "pages": "304--337",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Gaifman, Haim. 1965. Dependency systems and phrase-structure systems. Information and Control, 8:304-337.",
                "links": null
            },
            "BIBREF22": {
                "ref_id": "b22",
                "title": "Parsing Schemata for Practical Text Analysis",
                "authors": [
                    {
                        "first": "Carlos",
                        "middle": [],
                        "last": "G\u00f3mez-Rodr\u00edguez",
                        "suffix": ""
                    }
                ],
                "year": 2009,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "G\u00f3mez-Rodr\u00edguez, Carlos. 2009. Parsing Schemata for Practical Text Analysis. Ph.D. thesis, Universidade da Coru\u00f1a, Spain.",
                "links": null
            },
            "BIBREF23": {
                "ref_id": "b23",
                "title": "A deductive approach to dependency parsing",
                "authors": [
                    {
                        "first": "Carlos",
                        "middle": [],
                        "last": "G\u00f3mez-Rodr\u00edguez",
                        "suffix": ""
                    },
                    {
                        "first": "John",
                        "middle": [],
                        "last": "Carroll",
                        "suffix": ""
                    },
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Weir",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "Proceedings of the 46th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies (ACL'08:HLT)",
                "volume": "",
                "issue": "",
                "pages": "968--976",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "G\u00f3mez-Rodr\u00edguez, Carlos, John Carroll, and David Weir. 2008. A deductive approach to dependency parsing. In Proceedings of the 46th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies (ACL'08:HLT), pages 968-976, Columbus, OH.",
                "links": null
            },
            "BIBREF24": {
                "ref_id": "b24",
                "title": "Optimal reduction of rule length in linear context-free rewriting systems",
                "authors": [
                    {
                        "first": "Carlos",
                        "middle": [],
                        "last": "G\u00f3mez-Rodr\u00edguez",
                        "suffix": ""
                    },
                    {
                        "first": "Marco",
                        "middle": [],
                        "last": "Kuhlmann",
                        "suffix": ""
                    },
                    {
                        "first": "Giorgio",
                        "middle": [],
                        "last": "Satta",
                        "suffix": ""
                    },
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Weir",
                        "suffix": ""
                    }
                ],
                "year": 2009,
                "venue": "Proceedings of NAACL HLT 2009: the Conference of the North American Chapter of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "539--547",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "G\u00f3mez-Rodr\u00edguez, Carlos, Marco Kuhlmann, Giorgio Satta, and David Weir. 2009. Optimal reduction of rule length in linear context-free rewriting systems. In Proceedings of NAACL HLT 2009: the Conference of the North American Chapter of the Association for Computational Linguistics, pages 539-547, Boulder, CO.",
                "links": null
            },
            "BIBREF25": {
                "ref_id": "b25",
                "title": "A compiler for parsing schemata. Software: Practice and Experience",
                "authors": [
                    {
                        "first": "Carlos",
                        "middle": [],
                        "last": "G\u00f3mez-Rodr\u00edguez",
                        "suffix": ""
                    },
                    {
                        "first": "Jes\u00fas",
                        "middle": [],
                        "last": "Vilares",
                        "suffix": ""
                    },
                    {
                        "first": "Miguel",
                        "middle": [
                            "A"
                        ],
                        "last": "Alonso",
                        "suffix": ""
                    }
                ],
                "year": 2009,
                "venue": "",
                "volume": "39",
                "issue": "",
                "pages": "441--470",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "G\u00f3mez-Rodr\u00edguez, Carlos, Jes\u00fas Vilares, and Miguel A. Alonso. 2009. A compiler for parsing schemata. Software: Practice and Experience, 39(5):441-470.",
                "links": null
            },
            "BIBREF26": {
                "ref_id": "b26",
                "title": "Parsing mildly non-projective dependency structures (extended version)",
                "authors": [
                    {
                        "first": "Carlos",
                        "middle": [],
                        "last": "G\u00f3mez-Rodr\u00edguez",
                        "suffix": ""
                    },
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Weir",
                        "suffix": ""
                    },
                    {
                        "first": "John",
                        "middle": [],
                        "last": "Carroll",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "G\u00f3mez-Rodr\u00edguez, Carlos, David Weir, and John Carroll. 2008. Parsing mildly non-projective dependency structures (extended version). Technical Report CSRP 600, Department of Informatics, University of Sussex.",
                "links": null
            },
            "BIBREF27": {
                "ref_id": "b27",
                "title": "Parsing mildly non-projective dependency structures",
                "authors": [
                    {
                        "first": "Carlos",
                        "middle": [],
                        "last": "G\u00f3mez-Rodr\u00edguez",
                        "suffix": ""
                    },
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Weir",
                        "suffix": ""
                    },
                    {
                        "first": "John",
                        "middle": [],
                        "last": "Carroll",
                        "suffix": ""
                    }
                ],
                "year": 2009,
                "venue": "Proceedings of the 12th Conference of the European Chapter of the Association for Computational Linguistics (EACL-09)",
                "volume": "",
                "issue": "",
                "pages": "291--299",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "G\u00f3mez-Rodr\u00edguez, Carlos, David Weir, and John Carroll. 2009. Parsing mildly non-projective dependency structures. In Proceedings of the 12th Conference of the European Chapter of the Association for Computational Linguistics (EACL-09), pages 291-299, Athens.",
                "links": null
            },
            "BIBREF29": {
                "ref_id": "b29",
                "title": "Prague Arabic dependency treebank: Development in data and tools",
                "authors": [
                    {
                        "first": "Jan",
                        "middle": [],
                        "last": "Haji\u010d",
                        "suffix": ""
                    },
                    {
                        "first": "Otakar",
                        "middle": [],
                        "last": "Smr\u017e",
                        "suffix": ""
                    },
                    {
                        "first": "Petr",
                        "middle": [],
                        "last": "Zem\u00e1nek",
                        "suffix": ""
                    },
                    {
                        "first": "Ja\u0148",
                        "middle": [],
                        "last": "Snaidauf",
                        "suffix": ""
                    },
                    {
                        "first": "Emanuel",
                        "middle": [],
                        "last": "Be\u0161ka",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "Proceedings of the NEMLAR International Conference on Arabic Language Resources and Tools",
                "volume": "",
                "issue": "",
                "pages": "110--117",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Haji\u010d, Jan, Otakar Smr\u017e, Petr Zem\u00e1nek, Ja\u0148 Snaidauf, and Emanuel Be\u0161ka. 2004. Prague Arabic dependency treebank: Development in data and tools. In Proceedings of the NEMLAR International Conference on Arabic Language Resources and Tools, pages 110-117, Cairo.",
                "links": null
            },
            "BIBREF30": {
                "ref_id": "b30",
                "title": "Beyond projectivity: Multilingual evaluation of constraints and measures on non-projective structures",
                "authors": [
                    {
                        "first": "Ji\u0159\u00ed",
                        "middle": [],
                        "last": "Havelka",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "ACL 2007: Proceedings of the 45th Annual Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "608--615",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Havelka, Ji\u0159\u00ed. 2007. Beyond projectivity: Multilingual evaluation of constraints and measures on non-projective structures. In ACL 2007: Proceedings of the 45th Annual Meeting of the Association for Computational Linguistics, pages 608-615, Prague.",
                "links": null
            },
            "BIBREF31": {
                "ref_id": "b31",
                "title": "Dependency theory: a formalism and some observations. Language",
                "authors": [
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Hays",
                        "suffix": ""
                    }
                ],
                "year": 1964,
                "venue": "",
                "volume": "40",
                "issue": "",
                "pages": "511--525",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Hays, David. 1964. Dependency theory: a formalism and some observations. Language, 40:511-525.",
                "links": null
            },
            "BIBREF32": {
                "ref_id": "b32",
                "title": "Textual entailment recognition based on dependency analysis and WordNet",
                "authors": [
                    {
                        "first": "Jes\u00fas",
                        "middle": [],
                        "last": "Herrera",
                        "suffix": ""
                    },
                    {
                        "first": "Anselmo",
                        "middle": [],
                        "last": "Pe\u00f1as",
                        "suffix": ""
                    },
                    {
                        "first": "Felisa",
                        "middle": [],
                        "last": "Verdejo",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "Machine Learning Challenges",
                "volume": "3944",
                "issue": "",
                "pages": "231--239",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Herrera, Jes\u00fas, Anselmo Pe\u00f1as, and Felisa Verdejo. 2005. Textual entailment recognition based on dependency analysis and WordNet. In J. Qui\u00f1onero-Camdela, I. Dagan, B. Magnini, and F. d'Alch\u00e9-Buc, editors, Machine Learning Challenges. Lecture Notes in Computer Science, vol. 3944. Springer-Verlag, Berlin- Heidelberg-New York, pages 231-239.",
                "links": null
            },
            "BIBREF33": {
                "ref_id": "b33",
                "title": "On parsing coupled-context-free languages",
                "authors": [
                    {
                        "first": "G\u00fcnter",
                        "middle": [],
                        "last": "Hotz",
                        "suffix": ""
                    },
                    {
                        "first": "Gisela",
                        "middle": [],
                        "last": "Pitsch",
                        "suffix": ""
                    }
                ],
                "year": 1996,
                "venue": "Theoretical Computer Science",
                "volume": "161",
                "issue": "1-2",
                "pages": "205--233",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Hotz, G\u00fcnter and Gisela Pitsch. 1996. On parsing coupled-context-free languages. Theoretical Computer Science, 161(1-2):205-233.",
                "links": null
            },
            "BIBREF34": {
                "ref_id": "b34",
                "title": "Tree-adjoining grammars",
                "authors": [
                    {
                        "first": "Aravind",
                        "middle": [
                            "K"
                        ],
                        "last": "Joshi",
                        "suffix": ""
                    },
                    {
                        "first": "Yves",
                        "middle": [],
                        "last": "Schabes",
                        "suffix": ""
                    }
                ],
                "year": 1997,
                "venue": "Handbook of Formal Languages",
                "volume": "3",
                "issue": "",
                "pages": "69--123",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Joshi, Aravind K. and Yves Schabes. 1997. Tree-adjoining grammars. In G. Rozenberg and A. Salomaa, editors, Handbook of Formal Languages, vol. 3: Beyond Words, Springer-Verlag, New York, NY, pages 69-123.",
                "links": null
            },
            "BIBREF35": {
                "ref_id": "b35",
                "title": "Pseudo-projectivity: A polynomially parsable non-projective dependency grammar",
                "authors": [
                    {
                        "first": "",
                        "middle": [],
                        "last": "Kahane",
                        "suffix": ""
                    },
                    {
                        "first": "Alexis",
                        "middle": [],
                        "last": "Sylvain",
                        "suffix": ""
                    },
                    {
                        "first": "Owen",
                        "middle": [],
                        "last": "Nasr",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Rambow",
                        "suffix": ""
                    }
                ],
                "year": 1998,
                "venue": "Proceedings of the 36th Annual Meeting of the Association for Computational Linguistics and the 17th International Conference on Computational Linguistics (COLING-ACL'98)",
                "volume": "",
                "issue": "",
                "pages": "646--652",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kahane, Sylvain, Alexis Nasr, and Owen Rambow. 1998. Pseudo-projectivity: A polynomially parsable non-projective dependency grammar. In Proceedings of the 36th Annual Meeting of the Association for Computational Linguistics and the 17th International Conference on Computational Linguistics (COLING-ACL'98), pages 646-652, San Francisco, CA.",
                "links": null
            },
            "BIBREF36": {
                "ref_id": "b36",
                "title": "An efficient recognition and syntax algorithm for context-free languages",
                "authors": [
                    {
                        "first": "Tadao",
                        "middle": [],
                        "last": "Kasami",
                        "suffix": ""
                    }
                ],
                "year": 1965,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kasami, Tadao. 1965. An efficient recognition and syntax algorithm for context-free languages. Scientific Report AFCRL-65-758, Air Force Cambridge Research Lab, Bedford, MA.",
                "links": null
            },
            "BIBREF37": {
                "ref_id": "b37",
                "title": "The Danish dependency treebank and the underlying linguistic theory",
                "authors": [
                    {
                        "first": "Matthias",
                        "middle": [
                            "T"
                        ],
                        "last": "Kromann",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "Proceedings of the 2nd Workshop on Treebanks and Linguistic Theories (TLT)",
                "volume": "",
                "issue": "",
                "pages": "217--220",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kromann, Matthias T. 2003. The Danish dependency treebank and the underlying linguistic theory. In Proceedings of the 2nd Workshop on Treebanks and Linguistic Theories (TLT), pages 217-220, V\u00e4xj\u00f6. Kuhlmann, Marco. 2007. Dependency Structures and Lexicalized Grammars. D. Phil dissertation, Saarland University, Saarbr\u00fccken, Germany.",
                "links": null
            },
            "BIBREF38": {
                "ref_id": "b38",
                "title": "Dependency Structures and Lexicalized Grammars: An Algebraic Approach",
                "authors": [
                    {
                        "first": "Marco",
                        "middle": [],
                        "last": "Kuhlmann",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "Lecture Notes in Computer Science",
                "volume": "6270",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kuhlmann, Marco. 2010. Dependency Structures and Lexicalized Grammars: An Algebraic Approach. Lecture Notes in Computer Science, vol. 6270. Springer, New York, NY.",
                "links": null
            },
            "BIBREF39": {
                "ref_id": "b39",
                "title": "Mildly context-sensitive dependency languages",
                "authors": [
                    {
                        "first": "Marco",
                        "middle": [],
                        "last": "Kuhlmann",
                        "suffix": ""
                    },
                    {
                        "first": "Mathias",
                        "middle": [],
                        "last": "M\u00f6hl",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "Proceedings of the 45th Annual Meeting of the Association for Computational Linguistics (ACL 2007)",
                "volume": "",
                "issue": "",
                "pages": "160--167",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kuhlmann, Marco and Mathias M\u00f6hl. 2007. Mildly context-sensitive dependency languages. In Proceedings of the 45th Annual Meeting of the Association for Computational Linguistics (ACL 2007), pages 160-167, Prague.",
                "links": null
            },
            "BIBREF40": {
                "ref_id": "b40",
                "title": "Mildly non-projective dependency structures",
                "authors": [
                    {
                        "first": "Marco",
                        "middle": [],
                        "last": "Kuhlmann",
                        "suffix": ""
                    },
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "Proceedings of the COLING/ACL 2006 Main Conference Poster Sessions",
                "volume": "",
                "issue": "",
                "pages": "507--514",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kuhlmann, Marco and Joakim Nivre. 2006. Mildly non-projective dependency structures. In Proceedings of the COLING/ACL 2006 Main Conference Poster Sessions, pages 507-514, Montreal.",
                "links": null
            },
            "BIBREF41": {
                "ref_id": "b41",
                "title": "An Earley-type recognizer for dependency grammar",
                "authors": [
                    {
                        "first": "Vincenzo",
                        "middle": [],
                        "last": "Lombardo",
                        "suffix": ""
                    },
                    {
                        "first": "Leonardo",
                        "middle": [],
                        "last": "Lesmo",
                        "suffix": ""
                    }
                ],
                "year": 1996,
                "venue": "Proceedings of the 16th International Conference on Computational Linguistics (COLING 96)",
                "volume": "",
                "issue": "",
                "pages": "723--728",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Lombardo, Vincenzo and Leonardo Lesmo. 1996. An Earley-type recognizer for dependency grammar. In Proceedings of the 16th International Conference on Computational Linguistics (COLING 96), pages 723-728, San Francisco, CA.",
                "links": null
            },
            "BIBREF42": {
                "ref_id": "b42",
                "title": "Characterizing discontinuity in constituent treebanks",
                "authors": [
                    {
                        "first": "Wolfgang",
                        "middle": [],
                        "last": "Maier",
                        "suffix": ""
                    },
                    {
                        "first": "Timm",
                        "middle": [],
                        "last": "Lichte",
                        "suffix": ""
                    }
                ],
                "year": 2011,
                "venue": "Lecture Notes in Computer Science",
                "volume": "5591",
                "issue": "",
                "pages": "164--179",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Maier, Wolfgang and Timm Lichte. 2011. Characterizing discontinuity in constituent treebanks. In P. de Grook, M. Egg, and L. Kallmeyer, editors, Formal Grammar, volume 5591 of Lecture Notes in Computer Science. Springer-Verlag, Berlin-Heidelberg- New York, pages 164-179.",
                "links": null
            },
            "BIBREF43": {
                "ref_id": "b43",
                "title": "Online large-margin training of dependency parsers",
                "authors": [
                    {
                        "first": "Ryan",
                        "middle": [],
                        "last": "Mcdonald",
                        "suffix": ""
                    },
                    {
                        "first": "Koby",
                        "middle": [],
                        "last": "Crammer",
                        "suffix": ""
                    },
                    {
                        "first": "Fernando",
                        "middle": [],
                        "last": "Pereira",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "ACL '05: Proceedings of the 43rd Annual Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "91--98",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "McDonald, Ryan, Koby Crammer, and Fernando Pereira. 2005. Online large-margin training of dependency parsers. In ACL '05: Proceedings of the 43rd Annual Meeting of the Association for Computational Linguistics, pages 91-98, Ann Arbor, MI.",
                "links": null
            },
            "BIBREF44": {
                "ref_id": "b44",
                "title": "Characterizing the errors of data-driven dependency parsing models",
                "authors": [
                    {
                        "first": "Ryan",
                        "middle": [],
                        "last": "Mcdonald",
                        "suffix": ""
                    },
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "Proceedings of the 2007 Joint Conference on Empirical Methods in Natural Language Processing and Computational Natural Language Learning",
                "volume": "",
                "issue": "",
                "pages": "122--131",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "McDonald, Ryan and Joakim Nivre. 2007. Characterizing the errors of data-driven dependency parsing models. In Proceedings of the 2007 Joint Conference on Empirical Methods in Natural Language Processing and Computational Natural Language Learning (EMNLP-CoNLL 2007), pages 122-131, Prague.",
                "links": null
            },
            "BIBREF45": {
                "ref_id": "b45",
                "title": "Nonprojective dependency parsing using spanning tree algorithms",
                "authors": [
                    {
                        "first": "Ryan",
                        "middle": [],
                        "last": "Mcdonald",
                        "suffix": ""
                    },
                    {
                        "first": "Fernando",
                        "middle": [],
                        "last": "Pereira",
                        "suffix": ""
                    },
                    {
                        "first": "Kiril",
                        "middle": [],
                        "last": "Ribarov",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "HLT/EMNLP 2005: Proceedings of the Conference on Human Language Technology and Empirical Methods in Natural Language Processing",
                "volume": "",
                "issue": "",
                "pages": "523--530",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "McDonald, Ryan, Fernando Pereira, Kiril Ribarov, and Jan Haji\u010d. 2005. Non- projective dependency parsing using spanning tree algorithms. In HLT/EMNLP 2005: Proceedings of the Conference on Human Language Technology and Empirical Methods in Natural Language Processing, pages 523-530, Vancouver.",
                "links": null
            },
            "BIBREF46": {
                "ref_id": "b46",
                "title": "On the complexity of non-projective data-driven dependency parsing",
                "authors": [
                    {
                        "first": "Ryan",
                        "middle": [],
                        "last": "Mcdonald",
                        "suffix": ""
                    },
                    {
                        "first": "Giorgio",
                        "middle": [],
                        "last": "Satta",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "IWPT 2007: Proceedings of the 10th International Conference on Parsing Technologies",
                "volume": "",
                "issue": "",
                "pages": "121--132",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "McDonald, Ryan and Giorgio Satta. 2007. On the complexity of non-projective data-driven dependency parsing. In IWPT 2007: Proceedings of the 10th International Conference on Parsing Technologies, pages 121-132, Prague.",
                "links": null
            },
            "BIBREF47": {
                "ref_id": "b47",
                "title": "MAMBA meets TIGER: Reconstructing a Swedish treebank from antiquity",
                "authors": [
                    {
                        "first": "Jens",
                        "middle": [],
                        "last": "Nilsson",
                        "suffix": ""
                    },
                    {
                        "first": "Johan",
                        "middle": [],
                        "last": "Hall",
                        "suffix": ""
                    },
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "Proceedings of NODALIDA 2005 Special Session on Treebanks",
                "volume": "",
                "issue": "",
                "pages": "119--132",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nilsson, Jens, Johan Hall, and Joakim Nivre. 2005. MAMBA meets TIGER: Reconstructing a Swedish treebank from antiquity. In Proceedings of NODALIDA 2005 Special Session on Treebanks, pages 119-132, Joensuu.",
                "links": null
            },
            "BIBREF48": {
                "ref_id": "b48",
                "title": "An efficient algorithm for projective dependency parsing",
                "authors": [
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "Proceedings of the 8th International Workshop on Parsing Technologies (IWPT 03)",
                "volume": "",
                "issue": "",
                "pages": "149--160",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nivre, Joakim. 2003. An efficient algorithm for projective dependency parsing. In Proceedings of the 8th International Workshop on Parsing Technologies (IWPT 03), pages 149-160, Nancy.",
                "links": null
            },
            "BIBREF49": {
                "ref_id": "b49",
                "title": "Riedel, and Deniz Yuret. 2007. The CoNLL 2007 shared task on dependency parsing",
                "authors": [
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "The Annual Conference of the North American Chapter of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "915--932",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nivre, Joakim. 2007. Incremental non-projective dependency parsing. In Proceedings of NAACL HLT 2007: The Annual Conference of the North American Chapter of the Association for Computational Linguistics, pages 396-403, Rochester, NY. Nivre, Joakim, Johan Hall, Sandra K\u00fcbler, Ryan McDonald, Jens Nilsson, Sebastian Riedel, and Deniz Yuret. 2007. The CoNLL 2007 shared task on dependency parsing. In Proceedings of the CoNLL Shared Task Session of EMNLP-CoNLL 2007, pages 915-932, Prague.",
                "links": null
            },
            "BIBREF50": {
                "ref_id": "b50",
                "title": "Memory-based dependency parsing",
                "authors": [
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    },
                    {
                        "first": "Johan",
                        "middle": [],
                        "last": "Hall",
                        "suffix": ""
                    },
                    {
                        "first": "Jens",
                        "middle": [],
                        "last": "Nilsson",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "Proceedings of the 8th Conference on Computational Natural Language Learning (CoNLL-2004)",
                "volume": "",
                "issue": "",
                "pages": "49--56",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nivre, Joakim, Johan Hall, and Jens Nilsson. 2004. Memory-based dependency parsing. In Proceedings of the 8th Conference on Computational Natural Language Learning (CoNLL-2004), pages 49-56, Boston, MA.",
                "links": null
            },
            "BIBREF51": {
                "ref_id": "b51",
                "title": "MaltParser: A languageindependent system for data-driven dependency parsing",
                "authors": [
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    },
                    {
                        "first": "Johan",
                        "middle": [],
                        "last": "Hall",
                        "suffix": ""
                    },
                    {
                        "first": "Jens",
                        "middle": [],
                        "last": "Nilsson",
                        "suffix": ""
                    },
                    {
                        "first": "Atanas",
                        "middle": [],
                        "last": "Chanev",
                        "suffix": ""
                    },
                    {
                        "first": "G\u00fcl\u015fen",
                        "middle": [],
                        "last": "Eryigit",
                        "suffix": ""
                    },
                    {
                        "first": "Sandra",
                        "middle": [],
                        "last": "K\u00fcbler",
                        "suffix": ""
                    },
                    {
                        "first": "Stetoslav",
                        "middle": [],
                        "last": "Marinov",
                        "suffix": ""
                    },
                    {
                        "first": "Erwin",
                        "middle": [],
                        "last": "Marsi",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "Natural Language Engineering",
                "volume": "13",
                "issue": "2",
                "pages": "99--135",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nivre, Joakim, Johan Hall, Jens Nilsson, Atanas Chanev, G\u00fcl\u015fen Eryigit, Sandra K\u00fcbler, Stetoslav Marinov, and Erwin Marsi. 2007. MaltParser: A language- independent system for data-driven dependency parsing. Natural Language Engineering, 13(2):99-135.",
                "links": null
            },
            "BIBREF52": {
                "ref_id": "b52",
                "title": "Labeled pseudo-projective dependency parsing with support vector machines",
                "authors": [
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    },
                    {
                        "first": "Johan",
                        "middle": [],
                        "last": "Hall",
                        "suffix": ""
                    },
                    {
                        "first": "Jens",
                        "middle": [],
                        "last": "Nilsson",
                        "suffix": ""
                    },
                    {
                        "first": "G\u00fcl\u015fen",
                        "middle": [],
                        "last": "Eryigit",
                        "suffix": ""
                    },
                    {
                        "first": "Stetoslav",
                        "middle": [],
                        "last": "Marinov",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "Proceedings of the 10th Conference on Computational Natural Language Learning (CoNLL-X)",
                "volume": "",
                "issue": "",
                "pages": "221--225",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nivre, Joakim, Johan Hall, Jens Nilsson, G\u00fcl\u015fen Eryigit, and Stetoslav Marinov. 2006. Labeled pseudo-projective dependency parsing with support vector machines. In Proceedings of the 10th Conference on Computational Natural Language Learning (CoNLL-X), pages 221-225, Sydney.",
                "links": null
            },
            "BIBREF53": {
                "ref_id": "b53",
                "title": "Integrating graph-based and transition-based dependency parsers",
                "authors": [
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    },
                    {
                        "first": "Ryan",
                        "middle": [],
                        "last": "Mcdonald",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "Proceedings of the 46th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies (ACL-08: HLT)",
                "volume": "",
                "issue": "",
                "pages": "950--958",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nivre, Joakim and Ryan McDonald. 2008. Integrating graph-based and transition-based dependency parsers. In Proceedings of the 46th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies (ACL-08: HLT), pages 950-958, Columbus, OH.",
                "links": null
            },
            "BIBREF54": {
                "ref_id": "b54",
                "title": "Pseudo-projective dependency parsing",
                "authors": [
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    },
                    {
                        "first": "Jens",
                        "middle": [],
                        "last": "Nilsson",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "ACL '05: Proceedings of the 43rd Annual Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "99--106",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nivre, Joakim and Jens Nilsson. 2005. Pseudo-projective dependency parsing. In ACL '05: Proceedings of the 43rd Annual Meeting of the Association for Computational Linguistics, pages 99-106, Ann Arbor, MI.",
                "links": null
            },
            "BIBREF55": {
                "ref_id": "b55",
                "title": "Building a Turkish treebank",
                "authors": [
                    {
                        "first": "Kemal",
                        "middle": [],
                        "last": "Oflazer",
                        "suffix": ""
                    },
                    {
                        "first": "Bilge",
                        "middle": [],
                        "last": "Say",
                        "suffix": ""
                    },
                    {
                        "first": "G\u00f6khan",
                        "middle": [],
                        "last": "Dilek Zeynep Hakkani-T\u00fcr",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "T\u00fcr",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "Building and Exploiting Syntacticallyannotated Corpora. Kluwer",
                "volume": "",
                "issue": "",
                "pages": "261--277",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Oflazer, Kemal, Bilge Say, Dilek Zeynep Hakkani-T\u00fcr, and G\u00f6khan T\u00fcr. 2003. Building a Turkish treebank. In A. Abeille, editor, Building and Exploiting Syntactically- annotated Corpora. Kluwer, Dordrecht, pages 261-277.",
                "links": null
            },
            "BIBREF56": {
                "ref_id": "b56",
                "title": "Recognition of linear context-free rewriting systems",
                "authors": [
                    {
                        "first": "Giorgio",
                        "middle": [],
                        "last": "Satta",
                        "suffix": ""
                    }
                ],
                "year": 1992,
                "venue": "Proceedings of the 30th Annual Meeting of the Association for Computational Linguistics (ACL'92)",
                "volume": "",
                "issue": "",
                "pages": "89--95",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Satta, Giorgio. 1992. Recognition of linear context-free rewriting systems. In Proceedings of the 30th Annual Meeting of the Association for Computational Linguistics (ACL'92), pages 89-95, Newark, DE.",
                "links": null
            },
            "BIBREF57": {
                "ref_id": "b57",
                "title": "A linguistic comparison of constituency, dependency, and link grammar",
                "authors": [
                    {
                        "first": "Gerold",
                        "middle": [],
                        "last": "Schneider",
                        "suffix": ""
                    }
                ],
                "year": 1998,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Schneider, Gerold. 1998. A linguistic comparison of constituency, dependency, and link grammar. M.Sc. thesis, University of Zurich, Switzerland.",
                "links": null
            },
            "BIBREF58": {
                "ref_id": "b58",
                "title": "A new string-to-dependency machine translation algorithm with a target dependency language model",
                "authors": [
                    {
                        "first": "Libin",
                        "middle": [],
                        "last": "Shen",
                        "suffix": ""
                    },
                    {
                        "first": "Jinxi",
                        "middle": [],
                        "last": "Xu",
                        "suffix": ""
                    },
                    {
                        "first": "Ralph",
                        "middle": [],
                        "last": "Weischedel",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "Proceedings of the 46th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies (ACL-08: HLT)",
                "volume": "",
                "issue": "",
                "pages": "577--585",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Shen, Libin, Jinxi Xu, and Ralph Weischedel. 2008. A new string-to-dependency machine translation algorithm with a target dependency language model. In Proceedings of the 46th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies (ACL-08: HLT), pages 577-585, Columbus, OH.",
                "links": null
            },
            "BIBREF59": {
                "ref_id": "b59",
                "title": "Principles and implementation of deductive parsing",
                "authors": [
                    {
                        "first": "Stuart",
                        "middle": [
                            "M"
                        ],
                        "last": "Shieber",
                        "suffix": ""
                    },
                    {
                        "first": "Yves",
                        "middle": [],
                        "last": "Schabes",
                        "suffix": ""
                    },
                    {
                        "first": "Fernando",
                        "middle": [
                            "C N"
                        ],
                        "last": "Pereira",
                        "suffix": ""
                    }
                ],
                "year": 1995,
                "venue": "Journal of Logic Programming",
                "volume": "24",
                "issue": "",
                "pages": "3--36",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Shieber, Stuart M., Yves Schabes, and Fernando C. N. Pereira. 1995. Principles and implementation of deductive parsing. Journal of Logic Programming, 24:3-36.",
                "links": null
            },
            "BIBREF60": {
                "ref_id": "b60",
                "title": "How to compare the structure of parsing algorithms",
                "authors": [
                    {
                        "first": "Klaas",
                        "middle": [],
                        "last": "Sikkel",
                        "suffix": ""
                    }
                ],
                "year": 1994,
                "venue": "Proceedings of ASMICS Workshop on Parsing Theory",
                "volume": "",
                "issue": "",
                "pages": "21--39",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Sikkel, Klaas. 1994. How to compare the structure of parsing algorithms. In Proceedings of ASMICS Workshop on Parsing Theory, pages 21-39, Milano.",
                "links": null
            },
            "BIBREF61": {
                "ref_id": "b61",
                "title": "Parsing Schemata -A Framework for Specification and Analysis of Parsing Algorithms",
                "authors": [
                    {
                        "first": "Klaas",
                        "middle": [],
                        "last": "Sikkel",
                        "suffix": ""
                    }
                ],
                "year": 1997,
                "venue": "Texts in Theoretical Computer Science -An EATCS Series",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Sikkel, Klaas. 1997. Parsing Schemata -A Framework for Specification and Analysis of Parsing Algorithms. Texts in Theoretical Computer Science -An EATCS Series. Springer-Verlag, Berlin-Heidelberg- New York.",
                "links": null
            },
            "BIBREF62": {
                "ref_id": "b62",
                "title": "Parsing English with a Link Grammar",
                "authors": [
                    {
                        "first": "Daniel",
                        "middle": [],
                        "last": "Sleator",
                        "suffix": ""
                    },
                    {
                        "first": "Davy",
                        "middle": [],
                        "last": "Temperley",
                        "suffix": ""
                    }
                ],
                "year": 1991,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Sleator, Daniel and Davy Temperley. 1991. Parsing English with a Link Grammar. Technical report CMU-CS-91-196, Carnegie Mellon University, Pittsburgh, PA.",
                "links": null
            },
            "BIBREF63": {
                "ref_id": "b63",
                "title": "Parsing English with a Link Grammar",
                "authors": [
                    {
                        "first": "Daniel",
                        "middle": [],
                        "last": "Sleator",
                        "suffix": ""
                    },
                    {
                        "first": "Davy",
                        "middle": [],
                        "last": "Temperley",
                        "suffix": ""
                    }
                ],
                "year": 1993,
                "venue": "Proceedings of the Third International Workshop on Parsing Technologies (IWPT'93)",
                "volume": "",
                "issue": "",
                "pages": "277--292",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Sleator, Daniel and Davy Temperley. 1993. Parsing English with a Link Grammar. In Proceedings of the Third International Workshop on Parsing Technologies (IWPT'93), pages 277-292, Tilburg.",
                "links": null
            },
            "BIBREF64": {
                "ref_id": "b64",
                "title": "The CoNLL-2008 shared task on joint parsing of syntactic and semantic dependencies",
                "authors": [
                    {
                        "first": "Mihai",
                        "middle": [],
                        "last": "Surdeanu",
                        "suffix": ""
                    },
                    {
                        "first": "Richard",
                        "middle": [],
                        "last": "Johansson",
                        "suffix": ""
                    },
                    {
                        "first": "Adam",
                        "middle": [],
                        "last": "Meyers",
                        "suffix": ""
                    },
                    {
                        "first": "Llu\u00eds",
                        "middle": [],
                        "last": "M\u00e0rquez",
                        "suffix": ""
                    },
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "Proceedings of the 12th Conference on Computational Natural Language Learning (CoNLL-2008)",
                "volume": "",
                "issue": "",
                "pages": "159--177",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Surdeanu, Mihai, Richard Johansson, Adam Meyers, Llu\u00eds M\u00e0rquez, and Joakim Nivre. 2008. The CoNLL-2008 shared task on joint parsing of syntactic and semantic dependencies. In Proceedings of the 12th Conference on Computational Natural Language Learning (CoNLL-2008), pages 159-177, Manchester.",
                "links": null
            },
            "BIBREF65": {
                "ref_id": "b65",
                "title": "Characterizing structural descriptions produced by various grammatical formalisms",
                "authors": [
                    {
                        "first": "K",
                        "middle": [],
                        "last": "Vijay-Shanker",
                        "suffix": ""
                    },
                    {
                        "first": "J",
                        "middle": [],
                        "last": "David",
                        "suffix": ""
                    },
                    {
                        "first": "Aravind",
                        "middle": [
                            "K"
                        ],
                        "last": "Weir",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Joshi",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "Proceedings of the 25th Annual Meeting of the Association for Computational Linguistics (ACL'87)",
                "volume": "",
                "issue": "",
                "pages": "104--111",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Vijay-Shanker, K., David J. Weir, and Aravind K. Joshi. 1987. Characterizing structural descriptions produced by various grammatical formalisms. In Proceedings of the 25th Annual Meeting of the Association for Computational Linguistics (ACL'87), pages 104-111, Stanford, CA. de Vreught, J. P. M. and H. J. Honig. 1989. A tabular bottom-up recognizer. Report 89-78, Delft University of Technology, Delft, the Netherlands.",
                "links": null
            },
            "BIBREF66": {
                "ref_id": "b66",
                "title": "Statistical dependency analysis with support vector machines",
                "authors": [
                    {
                        "first": "Hiroyasu",
                        "middle": [],
                        "last": "Yamada",
                        "suffix": ""
                    },
                    {
                        "first": "Yuji",
                        "middle": [],
                        "last": "Matsumoto",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "Proceedings of 8th International Workshop on Parsing Technologies (IWPT 2003)",
                "volume": "",
                "issue": "",
                "pages": "195--206",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Yamada, Hiroyasu and Yuji Matsumoto. 2003. Statistical dependency analysis with support vector machines. In Proceedings of 8th International Workshop on Parsing Technologies (IWPT 2003), pages 195-206, Nancy.",
                "links": null
            },
            "BIBREF67": {
                "ref_id": "b67",
                "title": "Recognition and parsing of context-free languages in time n 3",
                "authors": [
                    {
                        "first": "Daniel",
                        "middle": [
                            "H"
                        ],
                        "last": "Younger",
                        "suffix": ""
                    }
                ],
                "year": 1967,
                "venue": "Information and Control",
                "volume": "10",
                "issue": "2",
                "pages": "189--208",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Younger, Daniel H. 1967. Recognition and parsing of context-free languages in time n 3 . Information and Control, 10(2):189-208.",
                "links": null
            }
        },
        "ref_entries": {
            "FIGREF0": {
                "num": null,
                "uris": null,
                "type_str": "figure",
                "text": "Grounded extended dependency tree and associated dependency structure."
            },
            "FIGREF1": {
                "num": null,
                "uris": null,
                "type_str": "figure",
                "text": "Figure 4 Non-grounded extended dependency tree: A determiner and adjective have been found and, according to the grammar, we expect a noun that will act as their common head. As this head has not been read, no dependency links have been established."
            },
            "FIGREF2": {
                "num": null,
                "uris": null,
                "type_str": "figure",
                "text": "Figure 9 A structure which is strongly ill-nested for gap degree 1, but only mildly ill-nested for gap degree \u2265 2."
            },
            "TABREF1": {
                "type_str": "table",
                "html": null,
                "text": "n} where \u03b1 and \u03b2 are strings; P is a set of CFG-like rules; 7 and each item [A(\u03b1 \u2022 \u03b2), i, j] represents the set of projective extended dependency trees rooted at A, where the direct children of A are \u03b1\u03b2, and the subtrees rooted at \u03b1 have yield i..j.",
                "content": "<table><tr><td>Note that Lombardo and Lesmo's</td></tr><tr><td>parser uses both grounded trees (in items [A(\u03b1\u2022), i, j]) and non-grounded trees (in items</td></tr></table>",
                "num": null
            },
            "TABREF2": {
                "type_str": "table",
                "html": null,
                "text": "Deduction steps: The set of deduction steps for Att d is the following:",
                "content": "<table/>",
                "num": null
            },
            "TABREF3": {
                "type_str": "table",
                "html": null,
                "text": "is either of the form {h} \u222a[i..j] or {h} \u222a ([i..j] \\ [l..r]). WG1 is coherent if it contains a properly formed tree headed at h, such that h = {h} \u222a ([i..j] \\ [l..r]). Similarily for items of the form[i, j, h, , ], where",
                "content": "<table><tr><td>2.</td><td>All the nodes in T have gap degree at most 1 except for h, which can have</td></tr><tr><td/><td>gap degree up to 2.</td></tr><tr><td colspan=\"2\">An item [i, j, h, l, r] \u2208 I</td></tr></table>",
                "num": null
            },
            "TABREF4": {
                "type_str": "table",
                "html": null,
                "text": "Counts of dependency structures in treebanks for several languages, classified by projectivity, gap degree, and mild and strong ill-nestedness (for their gap degree).",
                "content": "<table><tr><td>Language</td><td/><td/><td/><td/><td colspan=\"2\">Structures</td><td/><td/><td/></tr><tr><td/><td>Total</td><td/><td/><td/><td colspan=\"2\">Nonprojective</td><td/><td/><td/></tr><tr><td/><td/><td>Total</td><td/><td colspan=\"2\">By gap degree</td><td/><td colspan=\"3\">By nestedness</td></tr><tr><td/><td/><td/><td>Gap deg 1</td><td>Gap deg 2</td><td>Gap deg 3</td><td>Gap deg &gt; 3</td><td>Well-nested</td><td>Mildly ill-nested</td><td>Strongly ill-nested</td></tr><tr><td>Arabic</td><td>2,995</td><td>205</td><td>189</td><td>13</td><td>2</td><td>1</td><td>204</td><td>1</td><td>0</td></tr><tr><td>Czech</td><td colspan=\"3\">87,889 20,353 19,989</td><td>359</td><td>4</td><td>1</td><td>20,257</td><td>96</td><td>0</td></tr><tr><td>Danish</td><td>5,430</td><td>864</td><td>854</td><td>10</td><td>0</td><td>0</td><td>856</td><td>8</td><td>0</td></tr><tr><td>Dutch</td><td>13,349</td><td>4,865</td><td>4,425</td><td>427</td><td>13</td><td>0</td><td>4,850</td><td>15</td><td>0</td></tr><tr><td>Latin</td><td>3,473</td><td>1,743</td><td>1,543</td><td>188</td><td>10</td><td>2</td><td>1,552</td><td>191</td><td>0</td></tr><tr><td>Portuguese</td><td>9,071</td><td>1,718</td><td>1,302</td><td>351</td><td>51</td><td>14</td><td>1,711</td><td>7</td><td>0</td></tr><tr><td>Slovene</td><td>1,998</td><td>555</td><td>443</td><td>81</td><td>21</td><td>10</td><td>550</td><td>5</td><td>0</td></tr><tr><td>Swedish</td><td>11,042</td><td>1,079</td><td>1,048</td><td>19</td><td>7</td><td>5</td><td>1,008</td><td>71</td><td>0</td></tr><tr><td>Turkish</td><td>5,583</td><td>685</td><td>656</td><td>29</td><td>0</td><td>0</td><td>665</td><td>20</td><td>0</td></tr></table>",
                "num": null
            }
        }
    }
}