Base_JSON/prefixJ/json/J12/J12-4002.json

{
    "paper_id": "J12-4002",
    "header": {
        "generated_with": "S2ORC 1.0.0",
        "date_generated": "2023-01-19T03:00:32.608619Z"
    },
    "title": "Finite-State Chart Constraints for Reduced Complexity Context-Free Parsing Pipelines",
    "authors": [
        {
            "first": "Brian",
            "middle": [],
            "last": "Roark",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "Oregon Health & Science University",
                "location": {
                    "postCode": "97006",
                    "settlement": "Beaverton",
                    "region": "Oregon",
                    "country": "USA"
                }
            },
            "email": "roarkbr@gmail.com"
        },
        {
            "first": "Kristy",
            "middle": [],
            "last": "Hollingshead",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "Oregon Health & Science University",
                "location": {
                    "postCode": "97006",
                    "settlement": "Beaverton",
                    "region": "Oregon",
                    "country": "USA"
                }
            },
            "email": ""
        },
        {
            "first": "Nathan",
            "middle": [],
            "last": "Bodenstab",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "Oregon Health & Science University",
                "location": {
                    "postCode": "97006",
                    "settlement": "Beaverton",
                    "region": "Oregon",
                    "country": "USA"
                }
            },
            "email": "bodenstab@gmail.com"
        }
    ],
    "year": "",
    "venue": null,
    "identifiers": {},
    "abstract": "We present methods for reducing the worst-case and typical-case complexity of a context-free parsing pipeline via hard constraints derived from finite-state pre-processing. We perform O(n) predictions to determine if each word in the input sentence may begin or end a multi-word constituent in chart cells spanning two or more words, or allow single-word constituents in chart cells spanning the word itself. These pre-processing constraints prune the search space for any chart-based parsing algorithm and significantly decrease decoding time. In many cases cell population is reduced to zero, which we term chart cell \"closing.\" We present methods for closing a sufficient number of chart cells to ensure provably quadratic or even linear worst-case complexity of context-free inference. In addition, we apply high precision constraints to achieve large typical-case speedups and combine both high precision and worst-case bound constraints to achieve superior performance on both short and long strings. These bounds on processing are achieved without reducing the parsing accuracy, and in some cases accuracy improves. We demonstrate that our method generalizes across multiple grammars and is complementary to other pruning techniques by presenting empirical results for both exact and approximate inference using the exhaustive CKY algorithm, the Charniak parser, and the Berkeley parser. We also report results parsing Chinese, where we achieve the best reported results for an individual model on the commonly reported data set.",
    "pdf_parse": {
        "paper_id": "J12-4002",
        "_pdf_hash": "",
        "abstract": [
            {
                "text": "We present methods for reducing the worst-case and typical-case complexity of a context-free parsing pipeline via hard constraints derived from finite-state pre-processing. We perform O(n) predictions to determine if each word in the input sentence may begin or end a multi-word constituent in chart cells spanning two or more words, or allow single-word constituents in chart cells spanning the word itself. These pre-processing constraints prune the search space for any chart-based parsing algorithm and significantly decrease decoding time. In many cases cell population is reduced to zero, which we term chart cell \"closing.\" We present methods for closing a sufficient number of chart cells to ensure provably quadratic or even linear worst-case complexity of context-free inference. In addition, we apply high precision constraints to achieve large typical-case speedups and combine both high precision and worst-case bound constraints to achieve superior performance on both short and long strings. These bounds on processing are achieved without reducing the parsing accuracy, and in some cases accuracy improves. We demonstrate that our method generalizes across multiple grammars and is complementary to other pruning techniques by presenting empirical results for both exact and approximate inference using the exhaustive CKY algorithm, the Charniak parser, and the Berkeley parser. We also report results parsing Chinese, where we achieve the best reported results for an individual model on the commonly reported data set.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Abstract",
                "sec_num": null
            }
        ],
        "body_text": [
            {
                "text": "Although there have been great advances in the statistical modeling of hierarchical syntactic structure over the past 15 years, exact inference with such models remains very costly and most rich syntactic modeling approaches resort to heavy pruning, pipelining, or both. Pipeline systems make use of simpler models with more efficient inference to reduce the search space of the full model. For example, the well-known Ratnaparkhi (1999) parser used a part-of-speech (POS)-tagger and a finite-state noun phrase (NP) chunker as initial stages of a multi-stage Maximum Entropy parser. The Charniak (2000) parser uses a simple probalistic context-free grammar (PCFG) to sparsely populate a chart for a richer model, and Charniak and Johnson (2005) added a discriminatively trained reranker to the end of that pipeline.",
                "cite_spans": [
                    {
                        "start": 419,
                        "end": 437,
                        "text": "Ratnaparkhi (1999)",
                        "ref_id": "BIBREF23"
                    },
                    {
                        "start": 587,
                        "end": 602,
                        "text": "Charniak (2000)",
                        "ref_id": "BIBREF5"
                    },
                    {
                        "start": 717,
                        "end": 744,
                        "text": "Charniak and Johnson (2005)",
                        "ref_id": "BIBREF5"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "Finite-state pre-processing for context-free parsing is very common as a means of reducing the amount of search required in the later stage. As mentioned earlier, the Ratnaparkhi pipeline used a finite-state POS-tagger and a finite-state NP-chunker to reduce the search space at the parsing stage, and achieved linear observed-time performance. Other recent examples of the utility of finite-state constraints for parsing pipelines include Glaysher and Moldovan (2006) , Djordjevic, Curran, and Clark (2007) , and Hollingshead and Roark (2007) . Similar hard constraints have been applied for dependency parsing, as will be outlined in Section 2. Note that by making use of preprocessing constraints, such approaches are no longer performing full exact inferencethese are approximate inference methods, as are the methods presented in this article.",
                "cite_spans": [
                    {
                        "start": 440,
                        "end": 468,
                        "text": "Glaysher and Moldovan (2006)",
                        "ref_id": "BIBREF15"
                    },
                    {
                        "start": 471,
                        "end": 507,
                        "text": "Djordjevic, Curran, and Clark (2007)",
                        "ref_id": "BIBREF9"
                    },
                    {
                        "start": 514,
                        "end": 543,
                        "text": "Hollingshead and Roark (2007)",
                        "ref_id": "BIBREF17"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "Using finite-state chunkers early in a syntactic parsing pipeline has shown both an efficiency (Glaysher and Moldovan 2006) and an accuracy (Hollingshead and Roark 2007) benefit for parsing systems. Glaysher and Moldovan (2006) demonstrated an efficiency gain by explicitly disallowing constituents that cross chunk boundaries. Hollingshead and Roark (2007) demonstrated that high-precision constraints on early stages of the Charniak and Johnson (2005) pipeline (in the form of base phrase constraints derived either from a chunker or from later stages of an earlier iteration of the same pipeline) achieved significant accuracy improvements, by moving the pipeline search away from unlikely areas of the search space. All of these approaches (as with Ratnaparkhi earlier) achieve improvements by ruling out parts of the search space, and the gain can either be realized in efficiency (same accuracy, less time) and/or accuracy (same time, greater accuracy).",
                "cite_spans": [
                    {
                        "start": 95,
                        "end": 123,
                        "text": "(Glaysher and Moldovan 2006)",
                        "ref_id": "BIBREF15"
                    },
                    {
                        "start": 140,
                        "end": 169,
                        "text": "(Hollingshead and Roark 2007)",
                        "ref_id": "BIBREF17"
                    },
                    {
                        "start": 199,
                        "end": 227,
                        "text": "Glaysher and Moldovan (2006)",
                        "ref_id": "BIBREF15"
                    },
                    {
                        "start": 328,
                        "end": 357,
                        "text": "Hollingshead and Roark (2007)",
                        "ref_id": "BIBREF17"
                    },
                    {
                        "start": 426,
                        "end": 453,
                        "text": "Charniak and Johnson (2005)",
                        "ref_id": "BIBREF5"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "Rather than extracting constraints from taggers or chunkers built for different purposes, in this study we have trained prediction models to more directly reduce the number of entries stored in cells of a dynamic programming chart during parsing-even to the point of \"closing\" chart cells to all entries. We demonstrate results using three finite-state taggers that assign each word position in the sequence with a binary class label. The first tagger decides if the word can begin a constituent of span greater than one word; the second tagger decides if the word can end a constituent of span greater than one word; and the third tagger decides if a chart cell spanning a single word should contain phrase-level non-terminals, or only POS tags. Following the prediction of each word, chart cells spanning multiple words can be completely closed as follows: Given a chart cell (b, e) spanning words w b . . . w e where b < e, we can \"close\" cell (b, e) if the first tagger decides that w b cannot be the first word of a multi-word constituent (MWC) or if the second tagger decides that w e cannot be the last word in a MWC. Completely closing sufficient chart cells allows us to impose worst-case complexity bounds on the overall pipeline, a bound that none of the other previously mentioned methods for finite-state preprocessing can guarantee.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "To complement closing multi-word constituent chart cells, our third tagger restricts the population of span-1 chart cells. We note that all span-1 chart cells must contain at least one POS tag and can therefore never be closed completely. Instead, our tagger restricts unary productions with POS tags on their right-hand side that span a single word. We term these single word constituents (SWCs). Disallowing SWCs alters span-1 cell population from potentially containing all non-terminals to just POS non-terminals. In practice, this decreases the number of entries in span-1 chart cells by 70% during exhaustive parsing, significantly reducing the number of allowable constituents in larger spans (Bodenstab, Hollingshead, and Roark 2011) . Span-1 chart cells are also the most frequently queried cells in the Cocke-Younger-Kasami (CKY) algorithm. The search over possible midpoints will always include two cells spanning a single word-one as the first left child and one as the last right child. It is therefore beneficial to minimize the number of entries in these span-1 cells.",
                "cite_spans": [
                    {
                        "start": 700,
                        "end": 741,
                        "text": "(Bodenstab, Hollingshead, and Roark 2011)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "The pre-processing framework we have outlined is straightforward to incorporate into most existing context-free constituent parsers, a task we have already done for several state-of-the art parsers. In the following sections we formally define our approach to finite-state chart constraints and analyze the accuracy of each of the three taggers and their impact on parsing efficiency and accuracy when used to prune the search space of a constituent parser. We apply our methods to exhaustive CYK parsing with simple grammars, as well as to high-accuracy parsing approaches such as the Charniak and Johnson (2005) parsing pipeline and the Berkeley parser Klein 2007a, 2007b) . Various methods for applying finite-state chart constraints are investigated, including methods that guarantee quadratic or linear complexity of the context-free parser.",
                "cite_spans": [
                    {
                        "start": 586,
                        "end": 613,
                        "text": "Charniak and Johnson (2005)",
                        "ref_id": "BIBREF5"
                    },
                    {
                        "start": 655,
                        "end": 674,
                        "text": "Klein 2007a, 2007b)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "Hard constraints are ubiquitous within parsing pipelines. One of the most basic and standard techniques is the use of a POS-tag dictionary, whereby words are only allowed to be assigned one of a subset of the POS-tag vocabulary, often based on what has been observed in the training data. This will overly constrain polysemous word types that happen not to have been observed with one of their possible tags; yet the large efficiency gain of so restricting the tags is typically seen as outweighing the loss in coverage. POStag preprocessing has been used for both context-free constituent parsing (Ratnaparkhi 1999) and dependency parsing (McDonald et al. 2005) . Richer tag sets can also be used to further constrain the parser, such as supertags (Bangalore and Joshi 1999) , which contain information about how the word will syntactically integrate with other words in the sequence. Supertagging has been widely used to make parsing algorithms efficient, particularly those making use of context-sensitive grammars (Clark and Curran 2004) .",
                "cite_spans": [
                    {
                        "start": 598,
                        "end": 616,
                        "text": "(Ratnaparkhi 1999)",
                        "ref_id": "BIBREF23"
                    },
                    {
                        "start": 640,
                        "end": 662,
                        "text": "(McDonald et al. 2005)",
                        "ref_id": "BIBREF19"
                    },
                    {
                        "start": 749,
                        "end": 775,
                        "text": "(Bangalore and Joshi 1999)",
                        "ref_id": "BIBREF0"
                    },
                    {
                        "start": 1018,
                        "end": 1041,
                        "text": "(Clark and Curran 2004)",
                        "ref_id": "BIBREF6"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "2."
            },
            {
                "text": "By applying finite-state chart constraints to constituent parsing, the approaches pursued in this article constrain the possible shapes of unlabeled trees, eliminating from consideration trees with constituents over specific spans. There is thus some similarity with other tagging approaches (e.g., supertagging) that dictate how words combine with the rest of the sentence via specific syntactic structures. Supertagging is generally used to enumerate which sorts of structures are licensed, whereas the constraints in this article indicate unlabeled tree structures that are proscribed. Along the same lines, there is a very general similarity with coarse-to-fine search methods, such as those used in the Berkeley (Petrov and Klein 2007a) and Charniak (2000) parsers, and more general structured prediction cascades (Weiss, Sapp, and Taskar 2010; . Our approach also uses simpler models that reduce the search space for larger downstream models.",
                "cite_spans": [
                    {
                        "start": 717,
                        "end": 741,
                        "text": "(Petrov and Klein 2007a)",
                        "ref_id": "BIBREF21"
                    },
                    {
                        "start": 746,
                        "end": 761,
                        "text": "Charniak (2000)",
                        "ref_id": "BIBREF5"
                    },
                    {
                        "start": 819,
                        "end": 849,
                        "text": "(Weiss, Sapp, and Taskar 2010;",
                        "ref_id": "BIBREF29"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "2."
            },
            {
                "text": "Dependency parsing involves constructing a graph of head/dependent relations, and many methods for constraining the space of possible dependency graphs have been investigated, such as requiring that each word have a single head or that the graph be acyclic. Nivre (2006) investigated the impact of such constraints on coverage and the number of candidate edges in the search space. Most interestingly, that paper found that constraining the degree of non-projectivity that is allowed can greatly reduce the number of arcs that must be considered during search, and, as long as some degree of non-projectivity is allowed, coverage is minimally impacted. Of course, the total absence of projectivity constraints allows for the use of spanning tree algorithms that can be quadratic complexity for certain classes of statistical models (McDonald et al. 2005) , so the ultimate utility of such constraints varies depending on the model being used.",
                "cite_spans": [
                    {
                        "start": 258,
                        "end": 270,
                        "text": "Nivre (2006)",
                        "ref_id": "BIBREF20"
                    },
                    {
                        "start": 832,
                        "end": 854,
                        "text": "(McDonald et al. 2005)",
                        "ref_id": "BIBREF19"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "2."
            },
            {
                "text": "Other hard constraints have been applied to dependency parsing, including constraints on the maximum length of dependencies (Eisner and Smith 2005; Dreyer, Smith, and Smith 2006) , which is known as vine parsing. Such vine parsers can be further constrained using taggers to determine the directionality and distance of each word's head in a way similar to our use of taggers (Sogaard and Kuhn 2009) . More general arc filtering approaches, using a variety of features (including some inspired by previously published results of methods presented in this article) have been proposed to reduce the number of arcs considered for the dependency graph (Bergsma and Cherry 2010; Cherry and Bergsma 2011) , resulting in large parsing speedups.",
                "cite_spans": [
                    {
                        "start": 124,
                        "end": 147,
                        "text": "(Eisner and Smith 2005;",
                        "ref_id": "BIBREF14"
                    },
                    {
                        "start": 148,
                        "end": 178,
                        "text": "Dreyer, Smith, and Smith 2006)",
                        "ref_id": "BIBREF10"
                    },
                    {
                        "start": 376,
                        "end": 399,
                        "text": "(Sogaard and Kuhn 2009)",
                        "ref_id": "BIBREF27"
                    },
                    {
                        "start": 648,
                        "end": 673,
                        "text": "(Bergsma and Cherry 2010;",
                        "ref_id": "BIBREF1"
                    },
                    {
                        "start": 674,
                        "end": 698,
                        "text": "Cherry and Bergsma 2011)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "2."
            },
            {
                "text": "In a context-free constituent parsing pipeline, constraints on the final parse structure can be made in stages preceding the CYK algorithm. For example, base phrase chunking (Hollingshead and Roark 2007) involves identifying a span as a base phrase of some category, often NP. A base phrase constituent has no children other than pre-terminal POS-tags, which all have a single terminal child (i.e., there is no internal structure in the base phrase involving non-POS non-terminals). This has a number of implications for the context-free parser. First, there is no need to build internal structure within the identified base phrase constituent. Second, constituents that cross brackets with the base phrase cannot be part of the final tree structure. This second constraint on possible trees can be thought of as a constraint on chart cells, as pointed out in Glaysher and Moldovan (2006) : No multi-word constituent can begin at a word falling within a base-phrase chunk, other than the first word of that chunk. Similarly, no multi-word constituent can end at a word falling within a base-phrase chunk, other than the last word of that chunk. These constraints rule out many possible structures that the full context-free parser would have otherwise considered.",
                "cite_spans": [
                    {
                        "start": 174,
                        "end": 203,
                        "text": "(Hollingshead and Roark 2007)",
                        "ref_id": "BIBREF17"
                    },
                    {
                        "start": 860,
                        "end": 888,
                        "text": "Glaysher and Moldovan (2006)",
                        "ref_id": "BIBREF15"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "2."
            },
            {
                "text": "These begin and end constraints can be extracted from the output of the chunker, but the chunker is most often trained to optimize chunking accuracy, not parsing accuracy (or parsing precision). Further, these constraints can apply even for words that fall outside of typical chunks. For example, in English, verbs and prepositions tend to occur before their arguments, hence are often unlikely to end constituents, yet verbs and prepositions are rarely inside a typically defined base phrase. Instead of imposing parsing constraints from NLP pre-processing steps such as chunking, we propose that building specific prediction models to constrain the search space within the CYK chart will more directly optimize efficiency within a parsing pipeline.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "2."
            },
            {
                "text": "In this article, we focus on linear complexity finite-state methods for deriving constraints on the chart. Recent work has also examined methods for constraining each of the O(N 2 ) chart cell independently (Bodenstab et al. 2011) , permitting a finer-grained pruning (e.g., not just \"open\" or \"closed\" but an actual beam width prediction) and the use of features beyond the scope of our tagger. We discuss this and other extensions of the current methods in our concluding remarks.",
                "cite_spans": [
                    {
                        "start": 207,
                        "end": 230,
                        "text": "(Bodenstab et al. 2011)",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "2."
            },
            {
                "text": "Dynamic programming for context-free inference generally makes use of a chart structure, as shown in Figure 1c for the left-binarized gold parse tree in Figure 1b . Each cell in the chart represents a collection of possible constituents covering a substring, which is identified by the indices of the first and last words of the substring. Let w 1 . . . w n be a string of n words to be parsed. The cell identified with (b, e) will contain possible constituents spanning the substring w b . . . w e , where the span of a constituent or a chart cell is defined as the number of words it covers, or e \u2212 b + 1. As an example, in this",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 101,
                        "end": 110,
                        "text": "Figure 1c",
                        "ref_id": null
                    },
                    {
                        "start": 153,
                        "end": 162,
                        "text": "Figure 1b",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Dynamic Programming Chart",
                "sec_num": "3.1"
            },
            {
                "text": "Gold parse tree (a), left-binarized representation of the same tree (b), and corresponding dynamic programming chart (c) for the sentence As usual, the real-estate market had overreacted. (sentence 1094 in WSJ Section 24). Each cell in the chart spans a unique substring of the input sentence. Non-terminals preceded with the symbol \"@\" are created through binarization (see Section 3.3).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "article we will occasionally refer to span-1 chart cells, meaning all chart cells covering a single word.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "Context-free inference using dynamic programming over a chart structure builds longer-span constituents by combining smaller span constituents, guided by rules in a context-free grammar. A context-free grammar G = (V, T, S \u2020 , P) consists of: a set of nonterminal symbols V, including a special start symbol S \u2020 ; a set of terminal symbols T; and a set of rule productions P of the form A \u2192 \u03b2 for A \u2208 V and \u03b2 \u2208 (V \u222a T) * , i.e., a single non-terminal on the left-hand side of the rule production, and a sequence of 0 or more terminals or non-terminals on the right-hand side of the rule. If we have a rule production A \u2192 B C \u2208 P, a completed B entry in chart cell (b, m) and a completed C entry in chart cell (m+1, e), we can place a completed A entry in chart cell (b, e). Such a chart cell entry is sometimes called an \"edge\" and can be represented by the tuple (A \u2192 B C, b, m, e).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "Context-free inference has cubic complexity in the length of the string N, due to the O(N 2 ) number of chart cells and O(N) possible child configurations at each cell. As an example, a cell spanning (b, e) must consider all possible configurations of two child constituents (child cells) that span a proper prefix (b, m) and a proper suffix (m+1, e) where b \u2264 m < e, leading to O(N) possible midpoints.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 1",
                "sec_num": null
            },
            {
                "text": "Algorithm 1 contains pseudocode for the CYK algorithm (Kasami 1965; Younger 1967; Cocke and Schwartz 1970) , where the context-free grammar G is assumed to be binarized. The function \u03c1 maps each grammar production in P to a probability. Lines 1-3",
                "cite_spans": [
                    {
                        "start": 54,
                        "end": 67,
                        "text": "(Kasami 1965;",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 68,
                        "end": 81,
                        "text": "Younger 1967;",
                        "ref_id": "BIBREF32"
                    },
                    {
                        "start": 82,
                        "end": 106,
                        "text": "Cocke and Schwartz 1970)",
                        "ref_id": "BIBREF7"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "Algorithm 1 CYK Pseudocode of the CYK algorithm using a binarized PCFG. Unary processing is simplified to allow only chains of length one (excluding lexical unary productions). Backpointer storage is omitted. \u03b1: Viterbi-max score for all non-terminals over every span",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "CYK(w 1 . . . w n , G = (V, T, S \u2020 , P, \u03c1)) 1: for s = 1 to n do Span width: bottom-up traversal 2: for b = 1 to n \u2212 s + 1 do",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "Begin word position 3:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "e \u2190 b+s\u22121 4:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "for A i \u2208 V do 5:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "if s = 1 then Add lexical productions 6:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "\u03b1 i (b, e) \u2190 \u03c1(A i \u2192 w b ) 7: else 8: \u03b1 i (b, e) \u2190 max b\u2264m<e max j,k \u03c1(A i \u2192 A j A k ) \u03b1 j (b, m) \u03b1 k (m + 1, e) 9",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": ":",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "for A i \u2208 V do",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "Add unary productions 10:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "\u03c5 i (b, e) \u2190 max \u03b1 i (b, e) , max j \u03c1(A i \u2192 A j ) \u03b1 j (b, e)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "11: \u03b1(b, e) \u2190 \u03c5(b, e) 12: return \u03b1 iterate over all O(N 2 ) chart cells in a bottom-up traversal. Line 6 initializes span-1 cells with all possible part-of-speech tags, and line 8 introduces the cubic complexity of the algorithm: maximization over all midpoints m, which is O(N). The variable \u03b1 stores the Viterbi-max score for each non-terminal A i \u2208 V at each cell (b, e), representing the span's most probable derivation rooted in A i . Backpointers indicating which argument(s) maximize each \u03b1 i (b, e) can be optionally recorded to efficiently extract the maximum likelihood solution at the end of inference, but we omit these for clarity; they are easily recoverable by storing the argmax for each max in lines 8 and 10.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "We have also included pseudocode in Algorithm 1 to process unary productions in lines 9 and 10. Unary processing is a necessary step to recover the gold-standard trees of the Penn treebanks (Marcus, Marcinkiewicz, and Santorini 1993; Xue et al. 2005) , but is often ignored in the presentation of the CYK algorithm. Because there is little discussion about unary processing in the literature, implementation details often differ from parser to parser. In Algorithm 1 we present a simplified version of unary processing that only allows unary chains of length 1 per span (excluding lexical productions). This approach is efficient and can be iterated as needed to represent the length of observed unary chain in the treebank. Note that line 10 uses the temporary variable \u03c5 to store the accumulated Viterbi-max scores \u03b1. This temporary variable is necessary due to the iterative nature in which we update \u03b1. If we were to write the result of line 10 directly to \u03b1 i (b, e), then the subsequent maximization of \u03b1 i+1 (b, e) would use an unstable version of \u03b1, some of which would already be updated with unary productions, and some which would not.",
                "cite_spans": [
                    {
                        "start": 190,
                        "end": 233,
                        "text": "(Marcus, Marcinkiewicz, and Santorini 1993;",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 234,
                        "end": 250,
                        "text": "Xue et al. 2005)",
                        "ref_id": "BIBREF31"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The CYK Algorithm",
                "sec_num": "3.2"
            },
            {
                "text": "A key feature to the efficiency of the CYK algorithm is that all productions in the grammar G are assumed to have no more than two right-hand-side children. Rather than trying to combine an arbitrary number of smaller substrings (child cells), the CYK algorithm exploits shared structure between rules and only needs to consider pairwise combination. To conform to this requirement, incomplete edges are needed to represent that further combination is required to achieve a complete edge. This can either be performed in advance, for example, by transforming a grammar into Chomsky Normal Form resulting in \"incomplete\" non-terminals created by the transform, or incomplete edges can be represented through so-called dotted rules, as with the Earley (1970) algorithm, in which transformation is essentially performed on the fly. For example, if we have a rule production A \u2192 B C D \u2208 P, a completed B entry in chart cell (b, m 1 ) and a completed C entry in chart cell (m 1 +1, m 2 ), then we can place an incomplete edge A \u2192 B C \u2022 D in chart cell (b, m 2 ). The dot signifies the division between what has already been combined (left of the dot), and what remains to be combined. Then, if we have an incomplete edge A \u2192 B C \u2022 D in chart cell (b, m 2 ) and a complete D in cell (m 2 +1, e), we can place a completed A entry in chart cell (b, e).",
                "cite_spans": [
                    {
                        "start": 743,
                        "end": 756,
                        "text": "Earley (1970)",
                        "ref_id": "BIBREF13"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incomplete Edges: Chomsky Normal Form and Dotted-Rules",
                "sec_num": "3.3"
            },
            {
                "text": "Transforming a grammar into Chomsky Normal Form (CNF) is an off-line operation that converts rules with more than two children on the right-hand side into multiple binary rules. To do this, composite non-terminals are created during the transformation, which represent incomplete constituents (i.e., those edges that require further combination to be made complete). 1 For example, if we have a rule production A \u2192 B C D in the context-free grammar G, then a new composite non-terminal would be created (e.g., @A:BC) and two binary rules would replace the previous ternary rule: A \u2192 @A:BC D and @A:BC \u2192 B C. The @A:BC non-terminal represents part of a rule expansion that needs to be combined with something else to produce a complete non-terminal from the original set of non-terminals. 2 In addition to binarization, one frequent modification to the grammar is to create a Markov model of the dependencies on the right-hand side of the rule. One way to do this is to reduce the number of children categories annotated on our new composite non-terminals introduced by binarization. For example, if instead of @A:BC we assign the label @A:C to our new non-terminal-with the semantics \"an incomplete A constituent with rightmost child C\"-then the two rules that result from binarization are: A \u2192 @A:C D and @A:C \u2192 B C. Probabilistically, the result of this is that the children non-terminals B and D are conditionally independent of each other given A and C. This approach will provide probability mass to combinations of children of the original category A that may not have been observed together, hence it should be seen as a form of smoothing. One can go further and remove all children categories from the new nonterminals (i.e., replacing @A:BC with just @A). This is the binarization pursued in the Berkeley parser, and is shown in Figure 1b .",
                "cite_spans": [
                    {
                        "start": 788,
                        "end": 789,
                        "text": "2",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 1838,
                        "end": 1847,
                        "text": "Figure 1b",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Incomplete Edges: Chomsky Normal Form and Dotted-Rules",
                "sec_num": "3.3"
            },
            {
                "text": "In this article, we explicitly discuss unary productions of type A \u2192 B where B is a non-terminal, and include these productions in our grammar. These productions violate the definition of a CNF grammar, and therefore we will use the term \"binarized grammar\" for the remainder of the article to indicate a grammar in CNF with the addition of unary productions. We will assume that all of our grammars have been previously binarized and we define V to be the set of non-terminals that are created through binarization, and denote edges where A \u2208 V as incomplete edges. Note that categories A \u2208 V are only used in binary productions, not unary productions, a consideration that will be used in our constrained parsing algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incomplete Edges: Chomsky Normal Form and Dotted-Rules",
                "sec_num": "3.3"
            },
            {
                "text": "In this section, we will explicitly define our chart constraints, and present methods for using the constraints to constrain parsing. We begin with constraints on beginning or ending multi-word constituents, then move to constraining span-1 chart cells.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Finite-State Chart Constraints",
                "sec_num": "4."
            },
            {
                "text": "Our task is to learn which words (in the appropriate context) can begin (B) or end (E) multi-word constituents. We will treat this as a pre-processing step to parsing and use these constraints to either completely or partially close chart cells during execution of the CYK algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Constituent Begin and End Constraints",
                "sec_num": "4.1"
            },
            {
                "text": "First, let us introduce notation. Given a set of labeled pairs (S, T) where S is a string of n words w 1 . . . w n and T is the target constituent parse tree for S, we say that word w b \u2208 B if there is a constituent spanning w b . . . w e for some e > b and w b \u2208 B otherwise. Similarly, we say that word w e \u2208 E if there is a constituent spanning w b . . . w e for some b < e and w e \u2208 E otherwise. Recovery of these labels will be treated as two separate binary tagging tasks (B/B and E/E). Although it may be obvious that we can rule out multi-word constituents with particular begin and end positions, there may be incomplete structures within the parser that should not be ruled out by these same constraints. Hence the notion of \"closing\" a chart cell is slightly more complicated than it may initially seem (which accounts for our use of quotes around the term). Consider the chart representation in Figure 2 with the following constraints, where B is the set of words disallowed from beginning a multi-word constituent and E is the set of words disallowed from ending a multi-word constituent 3 B : {\"usual\", \", \", \"real-estate\", \"market\", \"overreacted\"} E : {\", \", \"the\", \"real-estate\", \"had\"} Given our constraints, suppose that w b is in class B and w e is in class E, for b < e. We can \"close\" all cells (b, m 1 ) such that m 1 > b and all cells (m 2 , e) such that m 2 < e, based on the fact that multi-word constituents cannot begin with word w b and cannot end with w e . In Figure 2 this is depicted by the black and gray diagonals through the chart, \"closing\" those chart cells.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 907,
                        "end": 915,
                        "text": "Figure 2",
                        "ref_id": "FIGREF0"
                    },
                    {
                        "start": 1490,
                        "end": 1498,
                        "text": "Figure 2",
                        "ref_id": "FIGREF0"
                    }
                ],
                "eq_spans": [],
                "section": "Constituent Begin and End Constraints",
                "sec_num": "4.1"
            },
            {
                "text": "If a chart cell (b, e) has been \"closed\" due to begin or end constraints then it is clear that complete edges should not be permitted in the cell since these represent precisely the multi-word constituents that are being ruled out. But what about incomplete edges that are introduced through grammar binarization or dotted rule parsing? To the extent that an incomplete edge can be extended to a valid complete edge, it must be allowed. There are two cases where this is possible. If w b \u2208 B, then under the assumption that incomplete edges are extended from left-to-right (see footnote 1), the incomplete edge should be discarded, because any completed edges that could result from extending that incomplete edge would have the same begin position. Stated another way, if w b \u2208 B for chart cell (b, e) then all chart cells (b, i) for i > b must also be closed. For example, in Figure 2 , the cell associated with the two-word substring real-estate market can be closed to both complete and incomplete edges, since real-estate \u2208 B, and any complete edge built from entries in that cell would also have to start with the same word and hence would be discarded. Thus, the whole diagonal is closed. If, however, w b \u2208 B and w e \u2208 E, such as the cell associated with the two-word substring the real-estate in Figure 2 , a complete edge-achieved by extending the incomplete edge-may end at w i for i > e, and cell (b, i) may be open (the real-estate market), hence the incomplete edge should be allowed in cell (b, e).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 878,
                        "end": 886,
                        "text": "Figure 2",
                        "ref_id": "FIGREF0"
                    },
                    {
                        "start": 1305,
                        "end": 1313,
                        "text": "Figure 2",
                        "ref_id": "FIGREF0"
                    }
                ],
                "eq_spans": [],
                "section": "Constituent Begin and End Constraints",
                "sec_num": "4.1"
            },
            {
                "text": "In Section 4.4 we discuss limitations on how such incomplete edges arise in closed cells, which has consequences for the worst-case complexity under certain conditions.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Constituent Begin and End Constraints",
                "sec_num": "4.1"
            },
            {
                "text": "In addition to begin and end constraints, we also introduce unary constraints in span-1 cells. Although we cannot close span-1 cells entirely because each of these cells must contain at least one POS tag, we can reduce the population of these cells by restricting the type of constituents they contain. We define a single-word constituent (SWC) as any unary production A \u2192 B in the grammar such that B is a non-terminal (not a lexicon entry) and the production spans a single word. The productions ADJP \u2192 JJ and VP \u2192 VBN in Figure 1a are examples of SWCs. Note that TOP \u2192 S and JJ \u2192usual in Figure 1a are also unary productions, but by definition they are not SWC unary productions. We train a distinct tagger, as is done for B and E constraints, to label each word position as either in U or U, indicating that the word position may or may not be extended by a SWC, respectively.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 524,
                        "end": 533,
                        "text": "Figure 1a",
                        "ref_id": null
                    },
                    {
                        "start": 591,
                        "end": 600,
                        "text": "Figure 1a",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Unary Constraints",
                "sec_num": "4.2"
            },
            {
                "text": "Because the search over possible grammar extension from two child cells in the CYK algorithm is analogous to a database JOIN operation, the efficiency of this crossproduct hinges on the population of the two child cells that are intersected. We focus on constraining the population of span-1 chart cells for three reasons. First, the begin/end constituent constraints only affect chart cells spanning more than one word and leave span-1 chart cells completely unpruned. By pruning entries in these span-1 cells, we complement multi-word constituent pruning so that all chart cells are now candidates for finite-state tagging constraints. Second, span-1 chart cells are the most frequently queried cells in the CYK algorithm. The search over possible midpoints will always include two cells spanning a single word-one as the first left child and one as the last right child. It is therefore important that the number of entries in these cells be minimized to make bottom-up CYK processing efficient. Finally, as we will show in Section 5, only 11.2% of words in the WSJ treebank are labeled with SWC productions. With oracle unary constraints, the possibility of constraining nearly 90% of span-1 chart cells has promising efficiency benefits to downstream processing.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Unary Constraints",
                "sec_num": "4.2"
            },
            {
                "text": "To reiterate, unary constraints in span-1 chart cells never close the cell completely because each span-1 cell must contain at least one POS non-terminal. Instead, if w i \u2208 U then we simply do not add phrase-level non-terminals to chart cell (i, i). Similar to chart cells spanning multiple words that cannot be closed completely, these span-1 chart cells partially restrict the population of the cell, which we will empirically show to reduce processing time over unconstrained CYK parsing. These partially closed chart cells are represented as gray in Figure 2 .",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 554,
                        "end": 562,
                        "text": "Figure 2",
                        "ref_id": "FIGREF0"
                    }
                ],
                "eq_spans": [],
                "section": "Unary Constraints",
                "sec_num": "4.2"
            },
            {
                "text": "Our discussion of cell closing in Section 4.1 highlighted different conditions for closing cells for complete and incomplete edges. We will refer to specific conditions in the pseudocode, which we enumerate here. The constraints determine three possible conditions for cell (b, e) spanning multiple words: We will refer to a chart cell (b, e) that matches the above condition as \"case 1 cells,\" \"case 2 cells,\" and so on, throughout the remainder of this article. Figure 2 represents these five cases pictorially, where case 1 cells are black, case 2 and 4 cells are gray, and case 3 and 5 cells are white. Algorithm 2 contains pseudocode of our modified CYK algorithm that takes into account B, E, and U constraints. Line 4 of Algorithm 2 is the first modification from the standard CYK processing of Algorithm 1: We now consider only words in set B to begin multi-word constituents. Chart cells excluded from this criteria fall into case 1 and require no work. Line 5 determines if chart cell (b, e) is of case 2 (partially open) or case 3 (completely open). If w e \u2208 E, then we skip to lines 16-17 and only incomplete edges are permitted. Note that there is only one possible midpoint for case 2 chart cells, which results in constant-time work (see proof in Section 4.4) and unary productions are not considered because all entries in the cell are incomplete constituents, which only participate in binary productions. Otherwise, if w e \u2208 E on Line 5, then the cell is open to all constituents and processing occurs as in the standard CYK algorithm (lines 6-10 of Algorithm 2 are identical to lines 4-8 of Algorithm 1). Finally, unary productions are added in lines 12-14, but restricted to multi-word spanning chart cells, or span-1 cells where w b \u2208 U.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 464,
                        "end": 472,
                        "text": "Figure 2",
                        "ref_id": "FIGREF0"
                    }
                ],
                "eq_spans": [],
                "section": "The Constrained CYK Algorithm",
                "sec_num": "4.3"
            },
            {
                "text": "All of the proofs in this section rely on constraints imposed by B and E. Pruning provided by the U constraints reduces decoding time in practice, but does not provide additional reductions in complexity. Our proofs of complexity bounds will rest on the number of cells that fall in cases 1-3 outlined in the Section 4.3, and the amount Algorithm 2 CONSTRAINEDCYK Pseudocode of a modified CYK algorithm, with constituent begin/end and unary constraints. Unary processing is simplified to allow only chains of length one (excluding lexical unary productions). Backpointer storage is omitted. \u03b1: Viterbi-max scores for all non-terminals over every span",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "CONSTRAINEDCYK(w 1 . . . w n , G = (V, T, S \u2020 , P, \u03c1), V , B, E, U)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "1: for s = 1 to n do Span width: bottom-up traversal 2:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "for b = 1 to n\u2212s+1 do Begin word position 3:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "e \u2190 b+s\u22121 4:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "if w b \u2208 B or s = 1 then Case 1 cells excluded 5:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "if w e \u2208 E or s = 1 then 6:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "for A i \u2208 V do 7:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "if s = 1 then Add lexical productions 8:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "\u03b1 i (b, b) \u2190 \u03c1(A i \u2192 w b ) 9: else Case 3: cell open 10: \u03b1 i (b, e) \u2190 max b\u2264m<e max j,k \u03c1(A i \u2192 A j A k ) \u03b1 j (b, m) \u03b1 k (m + 1, e)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "11: if s > 1 or w b \u2208 U then Case 5 for span-1 cells 12:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "for A i \u2208 V do Add unary productions 13: \u03c5 i (b, e) \u2190 max \u03b1 i (b, e) , max j \u03c1(A i \u2192 A j ) \u03b1 j (b, e)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "14: \u03b1(b, e) \u2190 \u03c5(b, e) 15: else Case 2: closed to complete constituents 16:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "for A i \u2208 V do",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "Only consider binarized non-terminals 17: More formally, we can define an upper bound on the work required in a chart cell as W = |P| \u2022 |M| where |P| is the number grammar productions bounded above by the constant size of the grammar, and |M| is the number of midpoints considered. We denote the upper bound on the amount of work done in case 1 cells by W 1 and the total number of case 1 cells considered by C 1 (similarly for case 2 and 3). With this decomposition, the complexity of the CONSTRAINEDCYK algorithm can be written as",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "\u03b1 i (b, e) \u2190 max j,k \u03c1(A i \u2192 A j A k ) \u03b1 j (b, e \u2212 1) \u03b1 k (e,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "O(|C 1 |W 1 + |C 2 |W 2 + |C 3 |W 3 )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": ". Because there is no work for case 1 cells (W 1 = 0), these can be ignored. In fact, we can reduce the complexity even further.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "Theorem 1 W 2 is constant and CONSTRAINEDCYK has complexity O(|C 2 | + |C 3 |W 3 ).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proofs to Bound Worst-Case Complexity",
                "sec_num": "4.4"
            },
            {
                "text": "Without loss of generality, we assume a left-binarized grammar. The upper bound on required work for cell (b, e) is defined as W = |P| \u2022 |M| where |P| is the number of grammar productions bounded above by the constant size of the grammar, and |M| is the number of midpoints considered. For some (b, e) where 1 \u2264 b < e \u2264 n, assume w b \u2208 B and w e \u2208 E, that is, (b, e) \u2208 C 2 . The possible child cells of (b, e) are (b, m) and (m + 1, e) where b \u2264 m < e. Because we assume a left-binarized grammar, the production's right child must be a complete non-terminal and (m + 1, e) \u2208 C 3 must hold. But w e \u2208 E so (m + 1, e) cannot be in C 3 unless m = e \u2212 1 (span 1 cell). Therefore, the only valid midpoint is m = e \u2212 1 and",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "W 2 = |P|\u20221 is constant, hence O(|C 2 |W 2 + |C 3 |W 3 ) = O(|C 2 | + |C 3 |W 3 ).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "In summary, we find that case 2 chart cells (gray in Figure 2 ) are surprisingly cheap to process because the right child cell must also be in case 2, resulting in only one possible midpoint to consider. Next, we show that bounding the number of open cells and applying Theorem 1 leads to quadratically bounded parsing.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 53,
                        "end": 61,
                        "text": "Figure 2",
                        "ref_id": "FIGREF0"
                    }
                ],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "If |C 3 | < \u03bbN for some constant \u03bb then CONSTRAINEDCYK has complexity O(N 2 ).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 2",
                "sec_num": null
            },
            {
                "text": "The total number of cells in the chart for a string of length N is N(N + 1)/2, therefore |C 2 | < N 2 . Further, the number of midpoints for any cell is less than N, hence W 3 < N. If we bound |C 3 | < \u03bbN, then it follows directly from Theorem 1 that CONSTRAINEDCYK has complexity O(",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "N 2 + \u03bbN \u2022 N) = O(N 2 ).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "We have just proved in Theorem 2 that we can reduce the complexity of constituent parsing from O(N 3 ) to O(N 2 ) by restricting the number of open cells in the chart via constraints B and E. Next, we will show that this bound can be reduced even further to O(N) when the number of words in B is held constant. We call this approach \"linear constraints.\" There are two things to note when considering these constraints. First, the proof relies only on the size of set B, leaving E potentially empty and limiting the efficiency gains on short sentence compared to high-precision and quadratically bounded constraints. Second, limiting the size of B to a constant value is a restrictive criterion. When applied to a long sentence, this will over-constrain the search space and impose a branching bias on possible trees. In Section 7.2 we show that if the branching bias from linear constraints matches the branching bias of the treebank, then accuracy is not severely affected and linear constraints can provide a useful bound on long sentences that often dominate computational resources.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "We first prove limits on the total number of open chart cells (case 3) and work required in these cells, which directly leads to the proof bounding the complexity of the algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "If |B| \u2264 \u03bb for some \u03bb, then W 3 \u2264 \u03bb|P|.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lemma 1",
                "sec_num": null
            },
            {
                "text": "It has been defined that W 1 is zero and shown in Theorem 1 that W 2 is constant. For chart cell (b, e) \u2208 C 3 there are e \u2212 b possible midpoints to consider. For some midpoint m where b \u2264 m < e, if w m \u2208 B then (m, e) \u2208 C 1 and contains no complete or incomplete constituent entries. Therefore midpoint m is not a valid midpoint for cell (b, e). Because |B| \u2264 \u03bb, there are at most \u03bb midpoints to consider and the work required in (b, e) is bounded above by the constant number of productions in the grammar (|P|) and \u03bb midpoints, thus W 3 \u2264 \u03bb|P|. ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "If |B| \u2264 \u03bb for some \u03bb then CONSTRAINEDCYK has complexity O(N).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 3",
                "sec_num": null
            },
            {
                "text": "From Theorem 1 we know that CONSTRAINEDCYK has complexity O(|C 2 | + |C 3 |W 3 ). Given that |B| \u2264 \u03bb, it follows from Lemmas 1 and 2 that CONSTRAINEDCYK has complexity O(\u03bb 2 N|P|) = O(N).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "In this section, we have been discussing worst-case complexity bounds, but there is a strong expectation for large typical-case complexity savings that aren't explicitly accounted for here. To provide some intuition as to why this might be, consider again the chart structure in Figure 2d . The black cells in the chart represent the cells that have been closed when w j \u2208 B (case 1 cells). Because there is no work required for these cells, the total amount of work required to parse the sentence is reduced. The quadratic bound does not include any potential reduction of work for the remaining open cells, however. Thus the amount of work to parse the sentence will be less than the worst-case quadratic bound because of this reduction in processing. In Section 7.2 we compute the empirical complexity of each constraint method and compare that with its theoretical bound.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 279,
                        "end": 288,
                        "text": "Figure 2d",
                        "ref_id": "FIGREF0"
                    }
                ],
                "eq_spans": [],
                "section": "Proof",
                "sec_num": null
            },
            {
                "text": "To better understand the proposed tagging tasks and their likely utility, we will first look at the distribution of classes and our ability to automatically assign them correctly.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "Note that we do not consider the first word w 1 and the last word w N during the begin-constituent and end-constituent prediction tasks because they are unambiguous in terms of whether they begin or end constituents of span greater than one. The first word w 1 must begin a constituent spanning the whole string, and the last word w N must end that same constituent. The first word w 1 cannot end a constituent of length greater than 1; similarly, the last word w N cannot begin a constituent of length greater than 1. We therefore omit B and E at these two word positions from prediction, leading to N \u2212 2 begin-constituent and N \u2212 2 end-constituent ambiguous predictions for a string of length N. (Marcus, Marcinkiewicz, and Santorini 1993) and the Penn Chinese treebank (Xue et al. 2005) , and the positive and negative class label frequency of all words in the data.",
                "cite_spans": [
                    {
                        "start": 699,
                        "end": 742,
                        "text": "(Marcus, Marcinkiewicz, and Santorini 1993)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 773,
                        "end": 790,
                        "text": "(Xue et al. 2005)",
                        "ref_id": "BIBREF31"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "From the nearly 1 million words in the English corpus, just over 870,000 are neither the first nor the last word in the string, therefore possible members of the sets B or E (i.e., neither beginning a multi-word constituent (B) nor ending a multi-word constituent (E)). Of these 870,000 words, over half (50.5%) do not begin multi-word constituents, and nearly three quarters (74.3%) do not end multi-word constituents. The skewed distribution of E to E reflects the right-branching structure of English. Finally, almost 90% of words are not labeled with a single-word constituent, demonstrating the infrequency at which these productions occur in the English treebank.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "The Chinese treebank is approximately half of the size of the English treebank in terms of the number of sentences and word count. Again, we see a bias towards right-branching trees (|B| > |E|), but the skew of the distributions is much smaller than it is for English. The most significant difference between the two corpora is the percentage of single-word constituents in Chinese compared with English. Due to the annotation guidelines of the Chinese treebank, nearly 40% of words contain single-word constituent unary productions. Because these occur with such high frequency, we can assume that unary constraints may have a smaller impact on efficiency for Chinese than for English, because an accurate tagger will constrain fewer cells. We still have the expectation, though, that accurate tagging of SWC productions will increase parsing accuracy for both English and Chinese.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "To automatically predict the class of each word position, we train a binary predictor from supervised data for each language/word-class pair, tuning performance on the respective development sets (WSJ Section 24 for English and Penn Chinese Treebank articles 301-325 for Chinese). Word classes are extracted from the treebank trees by observing constituents beginning or ending at each word position, or by observing single word constituents. We use the tagger from Hollingshead, Fisher, and Roark (2005) to train six linear models (three for English, three for Chinese) with the averaged perceptron algorithm (Collins 2002) . Table 2 summarizes the features implemented in our tagger for B, E, and U identification. In the table, the \u03d5 features are instantiated as POS-tags (provided by a separately trained log-linear POS-tagger) and \u03c4 features are instantiated as constituent tags (B, E, and U class labels). The feature set used in the tagger includes the n-grams of surrounding words, the n-grams of surrounding POS-tags, and the constituent tags of ",
                "cite_spans": [
                    {
                        "start": 466,
                        "end": 504,
                        "text": "Hollingshead, Fisher, and Roark (2005)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 610,
                        "end": 624,
                        "text": "(Collins 2002)",
                        "ref_id": "BIBREF8"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 627,
                        "end": 634,
                        "text": "Table 2",
                        "ref_id": "TABREF6"
                    }
                ],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "\u03c4 i \u03c4 i , w i \u03c4 i , w i [0] \u03c4 i , \u03d5 i \u03c4 i\u22121 , \u03c4 i \u03c4 i , w i\u22121 \u03c4 i , w i [0..1] \u03c4 i , \u03d5 i\u22121 \u03c4 i\u22122 , \u03c4 i \u03c4 i , w i+1 \u03c4 i , w i [0..2] \u03c4 i , \u03d5 i\u22121 , \u03d5 i \u03c4 i\u22122 , \u03c4 i\u22121 , \u03c4 i \u03c4 i , w i\u22122 \u03c4 i , w i [0..3] \u03c4 i , \u03d5 i+1 \u03c4 i , w i+2 \u03c4 i , w i [n] \u03c4 i , \u03d5 i , \u03d5 i+1 \u03c4 i , w i\u22121 , w i \u03c4 i , w i [n-1..n] \u03c4 i , \u03d5 i\u22121 , \u03d5 i , \u03d5 i+1 \u03c4 i , w i , w i+1 \u03c4 i , w i [n-2..n] \u03c4 i , \u03d5 i\u22122 \u03c4 i , w i [n-3..n] \u03c4 i , \u03d5 i\u22122 , \u03d5 i\u22121 \u03c4 i , w i \u2286 Digit \u03c4 i , \u03d5 i\u22122 , \u03d5 i\u22121 , \u03d5 i \u03c4 i , w i \u2286 UpperCase \u03c4 i , \u03d5 i+2 \u03c4 i , w i \u2286 Hyphen \u03c4 i , \u03d5 i+1 , \u03d5 i+2 \u03c4 i , \u03d5 i , \u03d5 i+1 , \u03d5 i+2",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "All lexical (LEX), orthographic (ORTHO), and part-of-speech (POS) features are duplicated to also occur with \u03c4 i\u22121 ; e.g.,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "{\u03c4 i\u22121 , \u03c4 i , w i } as a LEX feature.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "the preceding words. The n-gram features are represented by the words within a threeword window of the current word. The tag features are represented as unigram, bigram, and trigram tags (i.e., constituent tags from the current and two previous words). These features are based on the feature set implemented by Sha and Pereira (2003) for NP chunking. Additional orthographical features are used for unknown and rare words (words that occur fewer than five times in the training data), such as the prefixes and suffixes of the word (up to the first and last four characters of the word), and the presence of a hyphen, a digit, or a capitalized letter, following the features implemented by Ratnaparkhi (1999) . Note that the orthographic feature templates, including the prefix (e.g., w i [0..1]) and suffix (e.g., w i [n-2..n]) templates, are only activated for unknown and rare words. When applying our tagging model to Chinese data, all feature functions were left in the model as-is, and not tailored to the specifics of the language. We ran various tagging experiments on the development set and report accuracy results in Table 3 for all three predictions tasks, using Viterbi decoding. We trained models with Markov order-0 (constituent tags predicted for each word independently), order-1 (features with constituent tag pairs), and order-2 (features with constituent tag triples). In general, tagging accuracy for English is higher than for Chinese, especially for the U and B tasks. Given the consistent improvement from Markov order-0 to Markov order-1 (particularly on the Chinese data), and for the sake of consistency, we have chosen to perform Markov order-1 prediction for all results in the remainder of this article.",
                "cite_spans": [
                    {
                        "start": 312,
                        "end": 334,
                        "text": "Sha and Pereira (2003)",
                        "ref_id": "BIBREF26"
                    },
                    {
                        "start": 690,
                        "end": 708,
                        "text": "Ratnaparkhi (1999)",
                        "ref_id": "BIBREF23"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 1128,
                        "end": 1135,
                        "text": "Table 3",
                        "ref_id": "TABREF7"
                    }
                ],
                "eq_spans": [],
                "section": "Tagging Chart Constraints",
                "sec_num": "5."
            },
            {
                "text": "In the sections that follow, we present empirical trials to examine the behavior of chart constraints under a variety of conditions. First, we detail the data, evaluation, and parsers used in these experiments.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Experimental Set-up",
                "sec_num": "6."
            },
            {
                "text": "For English, all stochastic grammars are induced from the Penn WSJ Treebank (Marcus, Marcinkiewicz, and Santorini 1993) . Sections 2-21 of the treebank are used as training, Section 00 as held-out (for determining stopping criteria during training and some parameter tuning), Section 24 as development, and Section 23 as test set. For Chinese, we use the Penn Chinese Treebank (Xue et al. 2005) . Articles 1-270 and 400-1151 are used for training, articles 301-325 for both held-out and development, and articles 271-300 for testing. Supervised class labels are extracted from the non-binarized treebank trees for B, E, and U (as well as their complements).",
                "cite_spans": [
                    {
                        "start": 76,
                        "end": 119,
                        "text": "(Marcus, Marcinkiewicz, and Santorini 1993)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 377,
                        "end": 394,
                        "text": "(Xue et al. 2005)",
                        "ref_id": "BIBREF31"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Data Sets and Evaluation",
                "sec_num": "6.1"
            },
            {
                "text": "All results report F-measure labeled bracketing accuracy (harmonic mean of labeled precision and labeled recall) for all sentences in the data set (Black et al. 1991) , and timing is reported using an Intel 3.00GHz processor with 6MB of cache and 16GB of memory. Timing results include both the pre-processing time to tag the chart constraints as well as the subsequent context-free inference, but tagging time is relatively negligible as it takes less than three seconds to tag the entire development corpus.",
                "cite_spans": [
                    {
                        "start": 147,
                        "end": 166,
                        "text": "(Black et al. 1991)",
                        "ref_id": "BIBREF1"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Data Sets and Evaluation",
                "sec_num": "6.1"
            },
            {
                "text": "We have three separate tagging tasks, each with two possible tags for every word w i in the input string: (1) B or B; (2) E or E; and (3) U or U. Our taggers are as described in Section 5. Within a pipeline system that leverages hard constraints, one may want to choose a tagger operating point that favors precision of constraints over recall to avoid overconstraining the downstream parser. We have two methods for trading recall for precision that will be detailed later in this section, both relying on calculating the cumulative score S i for each of the binary tags at each word position w i . That is, (using B as the example tag):",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Methods and Closing Chart Cells",
                "sec_num": "6.2"
            },
            {
                "text": "EQUATION",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [
                    {
                        "start": 0,
                        "end": 8,
                        "text": "EQUATION",
                        "ref_id": "EQREF",
                        "raw_str": "S i (B | w 1 . . . w n ) = log \u03c4 1 ...\u03c4 n \u03b4(\u03c4 i , B) e \u03a6(w 1 ...w n ,\u03c4 1 ...\u03c4 n )\u2022w",
                        "eq_num": "(1)"
                    }
                ],
                "section": "Tagging Methods and Closing Chart Cells",
                "sec_num": "6.2"
            },
            {
                "text": "where sums over all possible tag sequences for sentence w 1 . . . w n ; \u03b4(\u03c4 i , B) = 1 if \u03c4 i = B and 0 otherwise; \u03a6(w 1 . . . w n , \u03c4 1 . . . \u03c4 n ) maps the word string and particular tag string to a d-dimensional (global) feature vector; and w is the d-dimensional parameter vector estimated by the averaged perceptron algorithm. Note that this cumulative score over all tag sequences that have B in position i can be calculated efficiently using the forwardbackward algorithm. We can compare the cumulative scores S i (B) and S i (B) to decide how to tag word w i , and define the cumulative score ratio (CSR) as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Methods and Closing Chart Cells",
                "sec_num": "6.2"
            },
            {
                "text": "EQUATION",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [
                    {
                        "start": 0,
                        "end": 8,
                        "text": "EQUATION",
                        "ref_id": "EQREF",
                        "raw_str": "CSR(w i ) = S i (B) \u2212 S i (B)",
                        "eq_num": "( 2 )"
                    }
                ],
                "section": "Tagging Methods and Closing Chart Cells",
                "sec_num": "6.2"
            },
            {
                "text": "If we want to tag B with high precision, and thus avoid over-constraining the parser, we can change our decision criterion to produce fewer such tags. We present two different selection criteria in the next two subsections.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Methods and Closing Chart Cells",
                "sec_num": "6.2"
            },
            {
                "text": "To show the effect of precision-oriented decision criteria, Figure 3 shows the precision/recall tradeoff at various operating points, using the global high-precision method detailed herein, for all three tags on both the English and the Chinese development sets. As expected, we see that the English B curve is significantly lower than the English E and U curves. This is due to the near-uniform prior on B in the data (E and U are much higher-frequency classes). Still, we can achieve 99% precision for B with recall above 70%. We do much better with E and U and see that when precision is 99% for these two tags, recall does not drop below 90%. For the Chinese tagging task, B, E, and U all have similar performance as we trade precision for recall. Here, as with the English B tag, we achieve 99% precision with recall still above 70%.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 60,
                        "end": 68,
                        "text": "Figure 3",
                        "ref_id": "FIGREF2"
                    }
                ],
                "eq_spans": [],
                "section": "Tagging Methods and Closing Chart Cells",
                "sec_num": "6.2"
            },
            {
                "text": "We can see from these results that our finite-state tagging approach yields very high accuracy on these tasks, as well as the ability to provide high precision (above 99%) operating points with a tolerable loss in recall. In what follows, we present two approaches to adjusting precision: first by adjusting the overall precision and recall of the tagger directly, as shown here; and second, by adjusting the precision and recall of tagging results on a per-sentence basis. We then discuss how complexity-bounded constraints are implemented in our experiments. In Section 7.1 we discuss empirical results showing how adjusting the tagger in these ways affects parsing performance. ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tagging Methods and Closing Chart Cells",
                "sec_num": "6.2"
            },
            {
                "text": "Global high precision constraints (GHP) are implemented using the cumulative score ratios directly to determine if w b \u2208 B or B. 4 Given the cumulative score ratio as defined herein, we define the set B under global high precision constraints as:",
                "cite_spans": [
                    {
                        "start": 129,
                        "end": 130,
                        "text": "4",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Global High Precision.",
                "sec_num": "6.2.1"
            },
            {
                "text": "EQUATION",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [
                    {
                        "start": 0,
                        "end": 8,
                        "text": "EQUATION",
                        "ref_id": "EQREF",
                        "raw_str": "GHP \u03bb (w i . . . w N ) = {w i \u2208 B : CSR(w i ) > \u03bb}",
                        "eq_num": "(3)"
                    }
                ],
                "section": "Global High Precision.",
                "sec_num": "6.2.1"
            },
            {
                "text": "The default decision boundary \u03bb = 0 provides high tagging accuracy, but as mentioned in Section 6.2 we may want to increase the precision of the tagger so that the subsequent parser is not over constrained. To do this, we increase the threshold parameter \u03bb towards positive infinity, potentially moving some words in the corpus from B to B. The same procedure is applied to E and U tags.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Global High Precision.",
                "sec_num": "6.2.1"
            },
            {
                "text": "Global high precision constraints, as defined here, affect the precision of the tagger over the entire corpus, but may or may not affect individual sentences. Because parsing operates on a sentence-by-sentence basis, it may be beneficial to modify the precision of the tagger based on the current sentence being processed. We call this approach sentence-level high precision (HP). 5 To increase tagging precision at the sentence level, we compute the cumulative scores S i and the cumulative scores ratio (CSR) at all word positions as described in this article. We next tag all word positions with a CSR(w i ) score less than zero with B, and rank the remaining word positions according to their CSR score. The lowestranking \u03bb fraction of this sorted list are tagged as B, and the rest default to B. When \u03bb = 0, zero percent of words are tagged with B (i.e., no constraints are applied); and when \u03bb = 1, 100 percent of the words with CSR(w i ) > 0 are tagged with B. This ensures that the high-precision threshold is adapted to each sentence, even if its absolute CSR scores are not similar to others in the corpus.",
                "cite_spans": [
                    {
                        "start": 381,
                        "end": 382,
                        "text": "5",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Sentence-Level High Precision.",
                "sec_num": "6.2.2"
            },
            {
                "text": "We impose quadratic bounds on context-free parsing by restricting the number of open cells (case 3 in Section 4.3) to be less than or equal to \u03bbN for some tuning parameter \u03bb and sentence length N. This only involves the sets B and E, as unary constraints are restricted to span-1 cells. Given gold parse trees t * and a function T (B, E) to generate the set of all valid parse trees satisfying constraints B and E, the optimal quadratically bounded constraints would be:",
                "cite_spans": [
                    {
                        "start": 331,
                        "end": 337,
                        "text": "(B, E)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Quadratic Bounds.",
                "sec_num": "6.2.3"
            },
            {
                "text": "EQUATION",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [
                    {
                        "start": 0,
                        "end": 8,
                        "text": "EQUATION",
                        "ref_id": "EQREF",
                        "raw_str": "Quad \u03bb (w i . . . w N ) = argmax B,E ( max t\u2208T(B,E) F 1 (t * , t) s.t. |C 3 | \u2264 \u03bbN)",
                        "eq_num": "( 4 )"
                    }
                ],
                "section": "Quadratic Bounds.",
                "sec_num": "6.2.3"
            },
            {
                "text": "that is, the set of constraints that provides the optimal F-score of the best remaining candidate in the chart while still imposing the required bound on the number of C 3 cells. This equation is an instance of combinatorial optimization and solving it exactly is NP-complete. Furthermore, we do not have access to gold parse trees t * during parsing and must rely on the posterior scores of the tagger. We instead use a greedy approach to approximate Equation (4). To accomplish this, at every sentence we first sort both the B and E CSR scores for each word position into a single list. Next, we assume all word positions are in B and E, then starting from the top of the sorted list (highest posterior probability for set inclusion), we continue to add word positions to their respective open set and compute the number of open cells with the given constraints while |C 3 | < \u03bbN. By doing this, we guarantee that only a linear number of case 3 cells are open in the chart, which leads to quadratic worst-case parsing complexity.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Quadratic Bounds.",
                "sec_num": "6.2.3"
            },
            {
                "text": "Imposing O(N) complexity bounds requires constraining the size of the set B such that |B| \u2264 \u03bb for some constant \u03bb. As with quadratic complexity bounds, we wish to find the optimal set B to fulfill these requirements:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Linear Bounds.",
                "sec_num": "6.2.4"
            },
            {
                "text": "EQUATION",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [
                    {
                        "start": 0,
                        "end": 8,
                        "text": "EQUATION",
                        "ref_id": "EQREF",
                        "raw_str": "Linear \u03bb (w i . . . w N ) = argmax B ( max t\u2208T(B) F 1 (t * , t) such that |B| \u2264 \u03bb)",
                        "eq_num": "( 5 )"
                    }
                ],
                "section": "Linear Bounds.",
                "sec_num": "6.2.4"
            },
            {
                "text": "We again resort to a greedy method to determine the set B, as this optimization problem is still NP-complete and gold trees are not available. B is constructed by sorting all word positions by their CSR scores for B, and then adding only the highest-scoring \u03bb entries to the inclusion set. All other word positions are closed and in the set B.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Linear Bounds.",
                "sec_num": "6.2.4"
            },
            {
                "text": "Because this method does not consider the set E to impose limits on processing, it will be shown in Section 7.2 that O(N) complexity bounding is not as effective as a stand-alone method when compared to the quadratic complexity or high precision constraints presented here.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Linear Bounds.",
                "sec_num": "6.2.4"
            },
            {
                "text": "We will present results constraining several different parsers. We first present results for exhaustive parsing using both the CYK and the CONSTRAINEDCYK algorithms. We use a basic CYK exhaustive parser, termed the BUBS parser, 6 to parse with a simple PCFG model that uses non-terminal node-labels as provided by the Penn Treebank, after removing empty nodes, node indices, and function tags. The results presented here replicate and extend the results presented in Roark and Hollingshead (2009) , using a different CYK parser. 7 The BUBS parser is an open-source high-efficiency parser that is grammar agnostic and can be run in either exhaustive mode or with various approximate inference options (detailed more fully in Section 8.1). It has been shown to parse exhaustively with very competitive or superior efficiency compared with other highly optimized CYK parsers (Dunlop, Bodenstab, and Roark 2011) . In contrast to the results in Roark and Hollingshead (2009) , here we present results with both leftand right-binarized PCFGs induced using a Markov order-2 transform, as detailed in Section 3.3, and also present results for parsing Chinese.",
                "cite_spans": [
                    {
                        "start": 467,
                        "end": 496,
                        "text": "Roark and Hollingshead (2009)",
                        "ref_id": "BIBREF25"
                    },
                    {
                        "start": 529,
                        "end": 530,
                        "text": "7",
                        "ref_id": null
                    },
                    {
                        "start": 872,
                        "end": 907,
                        "text": "(Dunlop, Bodenstab, and Roark 2011)",
                        "ref_id": "BIBREF12"
                    },
                    {
                        "start": 940,
                        "end": 969,
                        "text": "Roark and Hollingshead (2009)",
                        "ref_id": "BIBREF25"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Parsers",
                "sec_num": "6.3"
            },
            {
                "text": "We will then present results applying finite-state chart constraints to state-of-theart parsers, and evaluate the additional efficiency gains these constraints provide, even when these parsers are already heavily pruned. To simplify the presentation of these results, we concentrate in Section 7.1 on parsing with the simple Markov order-2 grammars, and then move to higher accuracy parsers in Section 8.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Parsers",
                "sec_num": "6.3"
            },
            {
                "text": "As mentioned in Section 6.2, we can adjust the severity of pruning to favor precision over recall. Figure 4a shows parse time versus F-measure labeled parse accuracy on the English development set for the baseline (unconstrained) exact-inference CYK parser, and for various parameterizations of global high precision (GHP), sentence-level high precision (HP), and unary constraints. Note that we see accuracy increasing over the baseline in Figure 4a with the imposition of these constraints at some operating points. This is not surprising, though, as the finite-state tagger makes use of lexical information that the simple PCFG does not, hence there is complementary information added that improves the model. The best operating points-fast parsing and relatively high accuracy-are achieved for GHP constraints at \u03bb = 40, for sentence-level HP at \u03bb = 0.95, and for unary constraints at \u03bb = 40. These high-precision parameterizations achieve roughly an order of magnitude speed-up and between 0.2 absolute (for unary constraints) and 3.7 absolute (for high-precision constraints) F-measure improvement over the baseline unconstrained parser.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 99,
                        "end": 108,
                        "text": "Figure 4a",
                        "ref_id": null
                    },
                    {
                        "start": 441,
                        "end": 450,
                        "text": "Figure 4a",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "High-Precision Constraints",
                "sec_num": "7.1"
            },
            {
                "text": "In order to analyze how these constraints affect accuracy with respect to sentence length, we turn to Figure 4b . In this plot, F-measure accuracy is computed over binned sentence lengths in increments of ten. All sentences of length greater than 60 are included in the final bin. As one might expect, accuracy declines with sentence length for all models because the number of possible trees is exponential in the sentence length and errors in one portion of the tree can adversely affect prediction of other constituents in nearby structures. We see that all constraints provide accuracy gains over the baseline at all sentence lengths, but point out that the gains by GHP B and E constraints are larger for longer sentences. As stated earlier, this is due to the model-correcting behavior of cell constraints: Lexical features are leveraged to prune trees that the PCFG may favor but are not syntactically correct with respect to the entire sentence. Because longer sentences are poorly modeled by the PCFG, cell constraints play a larger role in restricting the space of possible trees considered and correcting modeling errors.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 102,
                        "end": 111,
                        "text": "Figure 4b",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "High-Precision Constraints",
                "sec_num": "7.1"
            },
            {
                "text": "We can get a different perspective of how these constraints affect parsing time by considering the scatter plots in Figures 4c and 4d , which plot each sentence according to its length and parsing time at four operating points: baseline (unconstrained); global high precision at \u03bb = 40; sentence-level high precision at \u03bb = 0.95; and unary at \u03bb = 40. Figure 4c shows data points with up to 80 words and 400 msec of parsing time. Figure 4d zooms in to under 200 msec and up to 40 words. It can be seen in each graph that unconstrained CYK parsing quickly leaves the plotted area via a steep cubic curve (least-squares fit is N 2.9 ). Unary constraints operate at the same cubic complexity as the baseline, but with a constant factor decrease in parsing time (least-squares fit is also N 2.9 ). The plots for GHP and HP show dramatic decreases in typical-case runtime compared with the baseline. We again run a least-squares fit to the data and find that both GHP and HP constraints follow a N 2.5 trajectory.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 116,
                        "end": 133,
                        "text": "Figures 4c and 4d",
                        "ref_id": null
                    },
                    {
                        "start": 351,
                        "end": 360,
                        "text": "Figure 4c",
                        "ref_id": null
                    },
                    {
                        "start": 429,
                        "end": 438,
                        "text": "Figure 4d",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "High-Precision Constraints",
                "sec_num": "7.1"
            },
            {
                "text": "The empirical complexity and run-time performance of GHP and HP are nearly identical relative to all other chart constraints. But looking a little closer, we see in Figures 4c and 4d that that GHP constraints are slightly faster than HP for some sentences, and accumulated over the entire development set, this leads to both higher accuracy (75.1 vs. 74.6 F-measure) and faster parsing time (46 vs. 50 seconds). 8 This leads to the conclusion that when optimizing parameters for high-precision constraints, we can better tune the overall pipeline by choosing an operating point based on the corpus-level tagger performance as opposed to tuning for sentence-specific precision goals. Consequently, other than Table 4 , we only apply GHP constraints on test set results in the remainder of this section.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 165,
                        "end": 182,
                        "text": "Figures 4c and 4d",
                        "ref_id": null
                    },
                    {
                        "start": 708,
                        "end": 715,
                        "text": "Table 4",
                        "ref_id": "TABREF8"
                    }
                ],
                "eq_spans": [],
                "section": "High-Precision Constraints",
                "sec_num": "7.1"
            },
            {
                "text": "Although Figure 4a displays the constrained F-measure parse accuracy as a function of parsing time, one may also be interested in how tagger precision directly affects parse accuracy. To answer this question, we apply high precision constraints to sets B and E in isolation and plot results in Figure 5 . Note that when only constraints on E are applied, no chart cells can be completely closed and parsing time does not significantly decrease.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 9,
                        "end": 18,
                        "text": "Figure 4a",
                        "ref_id": null
                    },
                    {
                        "start": 294,
                        "end": 302,
                        "text": "Figure 5",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "High-Precision Constraints",
                "sec_num": "7.1"
            },
            {
                "text": "Likewise, when we apply constraints on B, a chart cell is either open to all constituents (case 3) or closed to all constituents (case 1). When constraining either B or E, we are predicting the structure of the final parse tree, which (as can be seen in Figure 5 ) has large effects on parse F-measure.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 254,
                        "end": 262,
                        "text": "Figure 5",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "High-Precision Constraints",
                "sec_num": "7.1"
            },
            {
                "text": "We point out in Figure 5 that to achieve optimal parsing F-measure, tagger precision must be above 97% for both English and Chinese. For both languages, B constraints are more forgiving and do not adversely affect parsing F-measure as quickly as E constraints. These results may lead one to tune two separate high-precision parametersone to constrain B and one to constrain E. We ran such experiments but found no significant gains compared to tying these parameters together. Figure 6a plots F-measure accuracy versus time to parse the entire development set for two complexity bounded constraints: O(N 2 ) and O(N). We also include the previously plotted global high-precision constraints for comparison. The large asterisk in the plot depicts the baseline accuracy and efficiency of standard CYK parsing without constraints. We sweep over various parameterizations for each method, from very lightly constrained to very heavily constrained. The complexity-bounded constraints are not combined with the high-precision constraints for this plot (but are later in the article).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 16,
                        "end": 24,
                        "text": "Figure 5",
                        "ref_id": null
                    },
                    {
                        "start": 477,
                        "end": 486,
                        "text": "Figure 6a",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "High-Precision Constraints",
                "sec_num": "7.1"
            },
            {
                "text": "As can be seen in Figure 6a , the linear-bounded method does not, as applied, achieve a favorable accuracy/efficiency tradeoff curve compared with the quadratic bound or high-precision constraints. This is not surprising, given that no words are excluded from the set E for this method, hence far fewer constraints overall are applied with the linear-bounded constraints.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 18,
                        "end": 27,
                        "text": "Figure 6a",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Complexity-Bounded Constraints",
                "sec_num": "7.2"
            },
            {
                "text": "In addition, we see in Figure 6b that unlike high precision and quadratic constraints, the linear method hurts accuracy on longer sentences over the baseline unconstrained algorithm, notably for sentences greater than 50 words. We attribute this to the fact that for longer sentences, say length 65, only \u03bb = 16 words are allowed in B for linear",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 23,
                        "end": 32,
                        "text": "Figure 6b",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Complexity-Bounded Constraints",
                "sec_num": "7.2"
            },
            {
                "text": "The effects of tagger precision on parsing F-measure. B and E constraints are applied in isolation; no other constraints are used during parsing. Results on the English development set in (a) and Chinese in (b). Baseline unconstrained F-measure accuracy is indicated with the horizontal black line.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 5",
                "sec_num": null
            },
            {
                "text": "English development set results (WSJ Section 24), applying complexity-bounding constraints with the CONSTRAINEDCYK algorithm. We sweep over multiple values of \u03bb in (a) and plot results in (b), (c), and (d) with the optimal value for each constraint found in (a). F-measure accuracy in (b) is computed over binned sentence lengths. constraints, which severely limits the search space for these sentences to the point of pruning gold constituents and decreasing overall accuracy.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 6",
                "sec_num": null
            },
            {
                "text": "Next we turn to the scatter plots of Figures 6c and 6d . Fitting an exponential curve to the data for each constraint via least-squares, we find that global high-precision constraints follow a N 2.5 trajectory, quadratic at N 1.6 , and linear at N 1.4 . It is interesting that quadratic constraints actually perform at sub-quadratic run-time complexity. This is because the quadric complexity proof in Section 4.4 assumes that the linear number of open cells each process O(N) midpoints. But in practice, many midpoints are not considered due to the heavily constrained chart, decreasing the average-case runtime of CONSTRAINEDCYK with quadratically bounded constraints.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 37,
                        "end": 54,
                        "text": "Figures 6c and 6d",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 6",
                "sec_num": null
            },
            {
                "text": "Also interesting is that linear constraints perform worse than O(N) at N 1.4 . We attribute this to the nature of the data set. When parsing with linear constraints, we see that for short sentences parsing complexity is actually cubic. Because we allow a constant number of word positions in the open set B, sentences with length less than \u03bb are completely unconstrained and all chart cells remain open. In Figure 6d it looks as if parsing becomes linear after the sentence length notably exceeds \u03bb, around N = 20. Assuming our corpus contained a disproportionate number of long sentences, empirical complexity of linear constraints should approach O(N), but due to the large number of short sentences, we see an empirical complexity greater than O(N).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 407,
                        "end": 416,
                        "text": "Figure 6d",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 6",
                "sec_num": null
            },
            {
                "text": "Three important points can be taken away from Figure 6 . First, although we can provably constrain parsing to linear speeds, in practice this method is inferior to both quadratically bounded constraints and high-precision constraints. Second, highprecision constraints are more accurate (see Figure 6b ) and more efficient (see Figure 6d) for shorter strings than the quadratically bound constraints; yet with longer strings the quadratic constraints better control parsing time than the high-precision constraints (see Figure 6c ). Finally, at the \"crossover\" point, where quadratic constraints start becoming more efficient than high-precision constraints (roughly 50-60 words, see Figure 4c ), there is a larger variance in the parsing time with high-precision constraints versus those with quadratic bounds. This illustrates the difference between the two methods of selecting constraints: High-precision constraints can provide very strong typical-case gains, but there is no guarantee of worst-case performance. In this way, the high-precision constraints are similar to other tagging-derived constraints like POS-tags or chunks.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 46,
                        "end": 54,
                        "text": "Figure 6",
                        "ref_id": null
                    },
                    {
                        "start": 292,
                        "end": 301,
                        "text": "Figure 6b",
                        "ref_id": null
                    },
                    {
                        "start": 328,
                        "end": 338,
                        "text": "Figure 6d)",
                        "ref_id": null
                    },
                    {
                        "start": 520,
                        "end": 529,
                        "text": "Figure 6c",
                        "ref_id": null
                    },
                    {
                        "start": 684,
                        "end": 693,
                        "text": "Figure 4c",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 6",
                "sec_num": null
            },
            {
                "text": "Depending on the length of the string, the complexity-bound constraints may close more or fewer chart cells than the high-precision constraints-more for long strings, fewer for short strings. We can achieve worst-case bounds along with superior typicalcase speed-ups by combining both methods. This is accomplished by taking the union of high-precision B, E, and U constraints with their respective complexity-bounded sets.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Combining Constraints",
                "sec_num": "7.3"
            },
            {
                "text": "When combining complexity-bound constraints with high-precision constraints, we first chose operating parameters for each complexity-bounded method at the point where efficiency is greatest and accuracy has yet to decline. These operating points can be seen as the \"knee\" of the curves in Figure 6a . For the quadratic complexity method, we set \u03bb = 4, limiting the number of open cells to 4N. For the linear complexity method, we set \u03bb = 12, limiting the number of word positions in B to a maximum of 12 members. Table 4 displays F-measure accuracy and parsing time (in seconds) for many individual and combined constraints on the development set: unconstrained CYK parsing; unary constraints; global high-precision (GHP) and sentence-level high-precision (HP) constraints; and O(N 2 ) and O(N) complexity-bounded constraints (Quad and Linear, respectively). We present all parsing results in Table 4 using both a left-and rightbinarized Markov order-2 grammar so that the effects of grammar binarization on finite-state constraints can be evaluated. Pre-processing the grammar with a right or left binarization alters the nature and distribution of child non-terminals for grammar productions. Because B and E constraints prune the chart differently depending on the grammar binarization, we suspect that one method may outperform the other due to the branching bias of the language being parsed.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 289,
                        "end": 298,
                        "text": "Figure 6a",
                        "ref_id": null
                    },
                    {
                        "start": 513,
                        "end": 520,
                        "text": "Table 4",
                        "ref_id": "TABREF8"
                    },
                    {
                        "start": 893,
                        "end": 900,
                        "text": "Table 4",
                        "ref_id": "TABREF8"
                    }
                ],
                "eq_spans": [],
                "section": "Combining Constraints",
                "sec_num": "7.3"
            },
            {
                "text": "We find three general trends in Table 4 . First, the efficiency benefits of combining constraints are relatively small. We suspect this is because the data set contains mostly shorter sentences. Global high-precision constraints outperform the complexity bounded constraints on sentences of length 10 to 50, which makes up the majority of the development set. It is not until we parse longer sentences that the trends start to differ and exhibit characteristics of the complexity bounds. Thus by combining high- precision and complexity constraints, we attain the typical-case efficiency benefits of high-precision constraints with worst-case complexity bounds. Second, we see that the efficiency gain combining unary and high-precision constraints is more than additive. Unary constraints alone for the right-binarized grammar decreased parsing time by 1.3x, but in conjunction with high-precision constraints, parsing time is decreased from 66 seconds to 37 seconds, an additional 1.8x speed-up. We suspect that this additional gain comes from cache efficiencies (due to the heavily pruned nature of the chart, the population of commonly-queried span-1 chart cells have a higher likelihood of remaining in high-speed cache, decreasing overall parsing time), but we leave empirical verification of this theory to future work.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 32,
                        "end": 39,
                        "text": "Table 4",
                        "ref_id": "TABREF8"
                    }
                ],
                "eq_spans": [],
                "section": "Combining Constraints",
                "sec_num": "7.3"
            },
            {
                "text": "The third trend we see in Table 4 is that there are significant efficiency differences when parsing with a right-or left-binarized grammar. The difference in baseline performance has been previously studied (Song, Ding, and Lin 2008; Dunlop, Bodenstab, and Roark 2010) , and our results confirm that a right-binarized grammar is superior for parsing the WSJ treebank due to the right-branching bias of parse trees in this corpus. Furthermore, linear constraints were far less effective with a left-binarized grammar, requiring a tuning parameter of \u03bb = 24 such that accuracy was not adversely affected (compare with \u03bb = 12 for right-binarized results). This is also caused by the branching bias inherent in the treebank. For example, consider a left-binarized grammar and linear constraints; in the extreme case where \u03bb = 0, only w 1 will be in the open set B, forcing all constituents in the final tree to start at w 1 . This results in a completely leftbranching tree. With a right-binarized grammar, only the last word position will be in E, resulting in a completely right-branching tree. Thus, an overly constrained linearbounded parse will favor one branching direction over the other. Because the treebank is biased towards right-branching trees, a right-binarized grammar is more favorable when linear constraints are applied. Finally, we note that after all constraints have been applied, the accuracy and efficiency differences between the two binarization strategies nearly disappear.",
                "cite_spans": [
                    {
                        "start": 207,
                        "end": 233,
                        "text": "(Song, Ding, and Lin 2008;",
                        "ref_id": "BIBREF28"
                    },
                    {
                        "start": 234,
                        "end": 268,
                        "text": "Dunlop, Bodenstab, and Roark 2010)",
                        "ref_id": "BIBREF11"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 26,
                        "end": 33,
                        "text": "Table 4",
                        "ref_id": "TABREF8"
                    }
                ],
                "eq_spans": [],
                "section": "Combining Constraints",
                "sec_num": "7.3"
            },
            {
                "text": "To validate the selected operating points on unseen data, we present results on the test sets for English in Table 5 and Chinese in Table 6 . 9 We parse individually with global high-precision and unary constraints, then present the combined result as this gave the best performance on the development set. In all cases, we see efficiency improvements greater than 10-fold and accuracy improvements of 4.4 absolute F-measure for English, and 8.4 absolute F-measure for Chinese. Note that these efficiency improvements are achieved with no additional techniques for speeding up search; modulo the cell closing mechanism, the CYK parsing is exhaustive-it explores all possible category combinations from all open child cells. Techniques such as coarse-to-fine, A * parsing, or beamsearch are all orthogonal to the current approach, and could be applied in conjunction to achieve additional speedups.",
                "cite_spans": [
                    {
                        "start": 142,
                        "end": 143,
                        "text": "9",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 109,
                        "end": 116,
                        "text": "Table 5",
                        "ref_id": "TABREF9"
                    },
                    {
                        "start": 132,
                        "end": 139,
                        "text": "Table 6",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Combining Constraints",
                "sec_num": "7.3"
            },
            {
                "text": "In the next section, we investigate the use of chart constraints with a number of high-accuracy parsers, and empirically evaluate the combination of our chart constraint methods with popular heuristic search methods for parsing. These parsers include the Charniak parser, the Berkeley parser, and an in-house beam-search parser.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Combining Constraints",
                "sec_num": "7.3"
            },
            {
                "text": "In this section we evaluate the additive efficiency gains provided by finite-state constraints to state-of-the-art parsers. We apply B, E, and U constraints to three parsers, all of which already prune the search space to make decoding time with large grammars more practical. Each high-accuracy parser that we evaluate also prunes the search space in a different way-agenda-based search, coarse-to-fine pruning, and beam-search. Applying finite-state constraints to these three distinct parsers demonstrates how our constraints interact with other well-known pruning algorithms. In what follows we describe the pruning inherent in the three parsers and how we apply finite-state constraints within each framework. 8.1.1 Charniak Parser. The Charniak (2000) parser is a multi-stage, agenda-driven parser that can be constrained by pruning edges before they are placed on the agenda. The first stage of the Charniak parser uses an agenda and a simple PCFG to build a sparse chart, which is used to limit the search in later stages with the full model. We focus on this first stage, because it is here that we will be constraining the parser. The edges on the agenda and in the chart are dotted rules, as described in Section 3.3. When edges are created, they are pushed onto the agenda. Edges that are popped from the agenda are placed in the chart, and then combined with other chart entries to create new edges that are pushed onto the agenda. Once a complete edge spanning the whole string is placed in the chart, at least one full solution must exist. Instead of terminating the initial chart population at this point, a technique called \"over-parsing\" is used that continues adding edges to the chart (and agenda) until a parameterized number of additional edges have been added. A small over-parsing value will heavily constrain the search space of the later stages within the pipeline, and a large value will often increase accuracy at the expense of efficiency. Upon reaching the desired number of edges, the next stage of the pipeline receives the chart as input and any edges remaining on the agenda are discarded.",
                "cite_spans": [
                    {
                        "start": 715,
                        "end": 757,
                        "text": "8.1.1 Charniak Parser. The Charniak (2000)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "High-Accuracy Parsing with Finite-State Chart Constraints",
                "sec_num": "8."
            },
            {
                "text": "We constrain the first stage of the Charniak parser by restricting agenda edges. When an edge is created for cell (b, e), where b < e, it is not placed on the agenda if either of the following two conditions hold: 1) w b \u2208 B; or 2) the edge is complete and w e \u2208 E. With these constraints, a large number of edges that would have previously been considered in the first stage of this pipeline will now be ignored. This allows us to either reduce the amount of over-parsing, which will increase efficiency, or maintain the over-parsing threshold and expand the search space in more promising directions according to the chart constraints. In this article, we have chosen to do the latter. Note that speed-ups are still observed, presumably due to the parser finding a complete edge spanning the whole sentence more quickly, thus leading to slight reductions in total edges added to the chart. (Petrov and Klein 2007a) is a multi-level coarseto-fine parser that operates over a set of coarse-to-fine grammars, G 1 . . . G t . At each grammar level, the inside and outside constituent probabilities are computed with coarse grammar G i and used to prune the subsequent search within G i+1 . This continues until the sentence is parsed with the target grammar G t . The initial grammar G 1 is a Markov order-0 grammar, and the target grammar G t is a latent-variable grammar induced through multiple iterations of splitting and merging non-terminals to maximize the likelihood of the training data (Petrov and Klein 2007b) . This explicit target grammar is very large, consisting of 4.3 million productions, 2.4 million of which are lexical productions. We refer to G t as the Berkeley grammar.",
                "cite_spans": [
                    {
                        "start": 892,
                        "end": 916,
                        "text": "(Petrov and Klein 2007a)",
                        "ref_id": "BIBREF21"
                    },
                    {
                        "start": 1494,
                        "end": 1518,
                        "text": "(Petrov and Klein 2007b)",
                        "ref_id": "BIBREF22"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Parsers",
                "sec_num": "8.1"
            },
            {
                "text": "We apply chart constraints to the Berkeley parser during the initial inside pass with grammar G 1 . Inside scores are computed via the CONSTRAINEDCYK algorithm of Algorithm 2 modulo the fact that the standard inside/outside sum over scores is used in lines 10, 13, and 17 instead of the Viterbi-max. It is unnecessary to constrain either the subsequent outside pass or the search with the following grammars G 2 . . . G t , as the coarse-to-fine algorithm only considers constituents remaining in the chart from the previous coarse grammar. Reducing the population of chart cells during the initial G 1 inside pass consequently prunes the search space for all levels of the coarse-to-fine search. We also note that even though there are t = 6 grammar levels in our experiments with the Berkeley parser, exhaustive parsing with G 1 consumes nearly 50% of the total parse time (Petrov, personal communication) . Applying chart constraints during this initial pass is where we see the largest efficiency gain-much more than when chart constraints supplement coarse-to-fine pruning in subsequent passes.",
                "cite_spans": [
                    {
                        "start": 875,
                        "end": 907,
                        "text": "(Petrov, personal communication)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Berkeley Parser. The Berkeley parser",
                "sec_num": "8.1.2"
            },
            {
                "text": "The bottom-up beam-search parser (BUBS) is a variation of the CYK algorithm where, at each chart cell, all possible edges are sorted by a Figure- of-Merit (FOM) and only the k-best edges are retained (Bodenstab et al. 2011) . We follow this setup and use the Boundary FOM (Caraballo and Charniak 1997 ), but do not apply beamwidth prediction in these experiments as chart constraints and beam-width prediction prune the search space in similar ways (see Bodenstab et al. [2011] for a comparison of the two methods). The BUBS parser is grammar agnostic, so to achieve high accuracy we parse with the Berkeley latent variable grammar (G t described in the previous subsection), yet only require a single pass over the chart. The BUBS parser performs Viterbi decoding and does not marginalize over the latent variables or compute the max-rule solution as is done in the Berkeley parser. This leads to a lower F-measure score in the final results even though both parsers use the same grammar.",
                "cite_spans": [
                    {
                        "start": 200,
                        "end": 223,
                        "text": "(Bodenstab et al. 2011)",
                        "ref_id": "BIBREF2"
                    },
                    {
                        "start": 272,
                        "end": 300,
                        "text": "(Caraballo and Charniak 1997",
                        "ref_id": "BIBREF4"
                    },
                    {
                        "start": 454,
                        "end": 477,
                        "text": "Bodenstab et al. [2011]",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 138,
                        "end": 145,
                        "text": "Figure-",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "BUBS Parser.",
                "sec_num": "8.1.3"
            },
            {
                "text": "In this article, we apply finite-state constraints to the BUBS parser in a fashion almost identical to the CONSTRAINEDCYK algorithm. Because the BUBS parser is a beam-search parser, the difference is that instead of retaining the max score for all nonterminals A i at each chart cell, we only retain the max score for the k-best non-terminals. Otherwise, B, E, and U constraints are used to prune the search space in the same way.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "BUBS Parser.",
                "sec_num": "8.1.3"
            },
            {
                "text": "Figure 7 displays accuracy and efficiency results of applying three independent constraints to the three parsers: high precision, quadratically bounded, and unary constraints. We sweep over possible tuning parameters from unconstrained (baseline",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "High-Accuracy Parsing Results",
                "sec_num": "8.2"
            },
            {
                "text": "English accuracy and efficiency results of applying high precision, quadratic, and unary constraints at multiple values of \u03bb to the Charniak, Berkeley, and BUBS parsers, all of which already heavily prune the search space. asterisk) to overly constrained such that accuracy is adversely affected. We also plot the optimal combination of high precision and quadratic constraints (diamond) and the combination of all three constraints (circle) for each parser which was computed via a grid search over the joint parameter space.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "There are many interesting patterns in Figure 7 . First, all three constraints independently improve the accuracy and efficiency of all three parsers, with the exception of accuracy in the Berkeley parser. This is a powerful result considering each of these parsers is simultaneously performing various alternative forms of pruning, which were (presumably) tuned for optimal accuracy and efficiency on this same data set. We also note that the efficiency gains from all three constraints are not identical. In particular, high precision and quadratic constraints outperforms unary constraints in isolation. But this should be expected as unary constraints only partially close O(n) chart cells whereas both high precision and quadratic constraints affect O(n 2 ) chart cells. Nevertheless, looking at the optimal point combining all three constraints, we see that adding unary constraints to begin/end constraints does provide additional gains (in both accuracy and efficiency) for the BUBS and Charniak parsers.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 39,
                        "end": 47,
                        "text": "Figure 7",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "The Berkeley parser appears to benefit from B and E constraints, but sees almost no gain from unary constraints. The reason for this has to do with the implementation details of combining (joining) two child cells within the inner loop of the CYK algorithm (line 8 in Algorithm 1). In bottom-up CYK parsing, to extend derivations of adjacent substrings into new constituents spanning the combined string, one can either iterate over all binary productions in the grammar and test if the new derivation is valid (we call this \"grammar loop\"), or one can take the cross-product of active entries in the cells spanning the substrings and poll the grammar for possible derivations (we call this \"cross-product\"). With the cross-product approach, fewer active entries in either child cell leads to fewer grammar access operations. Thus, pruning constituents in smallerspan cells directly affects the overall efficiency of parsing. On the other hand, with the grammar loop method there is a constant number of grammar access operations (i.e., the number of grammar productions) and the number of active entries in each child cell has little impact on efficiency. Therefore, with the grammar loop implementation of the CYK algorithm, pruning techniques such as unary constraints will have very little impact on the final run-time efficiency of the parser unless the list of grammar productions is modified given the constraints. For example, alternate iterators over grammar productions could be created such that they only consider a subset of all possible productions. If the left child is a span-1 chart cell in U, then only grammar productions with a POS tag as the left child need to be considered. Looping over this smaller list, opposed to all possible grammar productions, can reduce the overall runtime. The Berkeley parser contains the grammar-loop implementation of the CYK algorithm. Although all grammar productions are iterated over at each cell, the parser maintains meta-information indicating where non-terminals have been placed in the chart, allowing it to quickly skip over a subset of the productions that are incompatible with state of the chart. This optimization improves efficiency, but does not take full advantage of restricted cell population imposed by unary constraints, and thus does not benefit as greatly when compared to the BUBS or Charniak parsers.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "The second trend we see in Figure 7 is that accuracy actually improves with additional constraints. This is expected with the Charniak parser as we keep the amount of search space fixed in hopes of pursuing more accurate global paths, but both the Berkeley and BUBS parsers are simply eliminating search paths they would have otherwise considered. Although it is unusual that pruning leads to higher accuracy during search, it is not wholly unexpected here as our finite-state tagger makes use of lexical relationships that the PCFG does not (i.e., lexical relationships based on the linear string rather than over the syntactic structure). By leveraging this new information to constrain the search space, we are indirectly improving the quality of the model. We also suspect that the Berkeley parser sees less of an accuracy improvement than the BUBS parsers because the coarse-to-fine pruning within the Berkeley parser is more \"globally informed\" than the beam-search within the BUBS parser. By leveraging the coarse-grained inside/outside distribution of trees over the input sentence, the Berkeley parser can more intelligently prune the search space with respect to the target grammar and may not benefit from the additional information inherent in the finite-state tagging model.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 27,
                        "end": 35,
                        "text": "Figure 7",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "The third observation we point out in Figure 7 is that we see no additional gains from combining high-precision constraints with quadratic complexity constraints. With all three parsers, high-precision constraints are empirically superior to quadratic constraints, even though high-precision constraints come with no guarantee on worst-case complexity reduction. It is our hypothesis that the additional pruning provided by quadratic constraints for exhaustive CYK parsing is already removed by the internal pruning of each of the three high-accuracy parsers. We therefore report testing results using only high-precision and unary constraints for these high-accuracy parsers.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 38,
                        "end": 46,
                        "text": "Figure 7",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "We apply models tuned on the development set to unseen English test data (WSJ Section 23) in Table 7 , and Chinese test data (PCTB articles 271-300) in Table 8 . For English, we see similar trends as we did on the development set results: Decoding time is nearly halved when chart constraints are applied to these already heavily constrained parsers, without any loss in accuracy. We also see independent gains from both unary and high-precision constraints, and additive efficiency gains when combined.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 93,
                        "end": 100,
                        "text": "Table 7",
                        "ref_id": null
                    },
                    {
                        "start": 152,
                        "end": 159,
                        "text": "Table 8",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "Applying chart constraints to Chinese parsing in Table 8 gives substantially larger accuracy and efficiency gains than English for both the BUBS and Berkeley parser. In particular, the accuracy of the BUBS parser increases by 2.3 points absolute (p = 0.0002), Table 7 English test set results (WSJ Section 23) applying sentence-level high precision and unary constraints to three parsers with parameter settings tuned on development data. Table 8 Chinese test set results (PCTB articles 271-300) applying sentence-level high-precision and unary constraints to two parsers with parameter settings tuned on development data. and the Berkeley parser increases by 0.8 points absolute to 84.7 (p = 0.0119), the highest accuracy we are aware of for an individual model on this data set. 10, 11 These increases relative to English may be surprising as chart constraint tagging accuracy for Chinese is worse than English (see Table 3 ). We attribute this large gain to the lower baseline accuracy of parsing with the Chinese treebank, allowing our method to contribute additional syntactic constraints that were otherwise unmodeled by the PCFG.",
                "cite_spans": [
                    {
                        "start": 781,
                        "end": 784,
                        "text": "10,",
                        "ref_id": null
                    },
                    {
                        "start": 785,
                        "end": 787,
                        "text": "11",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 49,
                        "end": 56,
                        "text": "Table 8",
                        "ref_id": null
                    },
                    {
                        "start": 260,
                        "end": 267,
                        "text": "Table 7",
                        "ref_id": null
                    },
                    {
                        "start": 439,
                        "end": 446,
                        "text": "Table 8",
                        "ref_id": null
                    },
                    {
                        "start": 918,
                        "end": 925,
                        "text": "Table 3",
                        "ref_id": "TABREF7"
                    }
                ],
                "eq_spans": [],
                "section": "Figure 7",
                "sec_num": null
            },
            {
                "text": "We have presented finite-state pre-processing methods to constrain context-free parsing that reduce both the worst-case complexity and overall run time. Four unique bounding methods were presented, with high-precision constraints showing superior performance in empirical trials. Applying these constraints to context-free parsing increased efficiency by over 20 times for exhaustive CYK parsing, and nearly doubled the speed of the Charniak and Berkeley parsers-both of which have been previously tuned for optimal accuracy/efficiency performance. We have shown that our method generalizes across multiple grammars and languages, and that constraining both multi-word chart cells and single-word chart cells produces additive efficiency gains. In future work we plan to investigate additional methods to make context-free parsing more efficient. In particular, we believe the dynamic programming chart could be constrained even further if we take into account the population and structure of chart cells at a finer level. For example, the B and E constraints we have presented here do not take into account the height of the constituent they are predicting. Instead, they simply open or close the entire diagonal in the chart. Refining this structured prediction to bins, as is done in Zhang et al. (2010) , or classifying chart cells directly, as is done in Bodenstab et al. (2011) , has shown promise, but we believe that further research in this area would yield addition efficiency gains. In particular, those two papers do not differentiate between non-terminals when opening or closing cells, and we hypothesize that learning separate finite-state classifiers for automatically derived clusters of nonterminals may increase performance.",
                "cite_spans": [
                    {
                        "start": 1287,
                        "end": 1306,
                        "text": "Zhang et al. (2010)",
                        "ref_id": "BIBREF34"
                    },
                    {
                        "start": 1360,
                        "end": 1383,
                        "text": "Bodenstab et al. (2011)",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion and Future Work",
                "sec_num": "9."
            },
            {
                "text": "In this section we assume that edges are extended from left-to-right, which requires a left-binarization of the grammar, but everything carries over straightforwardly to the right-binarized case.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "In this example, the symbol \"@\" indicates that the new non-terminal is incomplete, and the symbol \":\" separates the original parent non-terminal from the children.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "In this example we list the actual words from the sentence for clarity withFigure 2, but in practice we classify word positions as a specific word may occur multiple times in the same sentence with potentially different B or E labels.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "In our experiments these scores are in the range \u00b110 3 . 5 As a historical note, we referred to this approach as simply \"high precision constraints\" inRoark and Hollingshead (2008) andRoark and Hollingshead (2009).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "http://code.google.com/p/bubs-parser. 7 Note that there are several differences between the two parsers, including the way in which grammars are induced, leading to different baseline accuracies and parsing times. Most notably, the parser fromRoark and Hollingshead (2009) relied upon POS-tagger output, and collapsed unary productions in a way that effectively led to parent annotation in certain unary chain constructions. The current results do not exploit those additional annotations, hence the baseline F-measure accuracy is a couple of percentage points lower.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "See Table 4for additional performance comparisons.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "We used the development set (articles 301-325 of the Penn Chinese treebank) to tune chart constraint parameters for Chinese, exactly as was done for English.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "Significance was tested using stratified shuffling. 11Zhang et al. (2009) report an F-measure of 85.5 with a k-best combination of parsers, and Burkett, Blitzer, and Klein (2010) report an F-measure of 86.0 by leveraging parallel English data for training, but our model is trained from the Chinese treebank alone and is integrated into the Berkeley parser, making it very efficient.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            }
        ],
        "back_matter": [
            {
                "text": "Portions of this paper have appeared in conference papers: Roark and Hollingshead (2008) , Roark and Hollingshead (2009) , and Bodenstab, Hollingshead, and Roark (2011). We thank three anonymous reviewers for their insightful comments and suggestions. Also thanks to Aaron Dunlop for being so swell. This research was supported in part by NSF grants IIS-0447214 and IIS-0811745, and DARPA grant HR0011-09-1-0041. Any opinions, findings, conclusions, or recommendations expressed in this publication are those of the authors and do not necessarily reflect the views of the NSF or DARPA.",
                "cite_spans": [
                    {
                        "start": 59,
                        "end": 88,
                        "text": "Roark and Hollingshead (2008)",
                        "ref_id": "BIBREF24"
                    },
                    {
                        "start": 91,
                        "end": 120,
                        "text": "Roark and Hollingshead (2009)",
                        "ref_id": "BIBREF25"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Acknowledgments",
                "sec_num": null
            }
        ],
        "bib_entries": {
            "BIBREF0": {
                "ref_id": "b0",
                "title": "Supertagging: an approach to almost parsing",
                "authors": [
                    {
                        "first": "Srinivas",
                        "middle": [],
                        "last": "Bangalore",
                        "suffix": ""
                    },
                    {
                        "first": "Aravind",
                        "middle": [
                            "K"
                        ],
                        "last": "Joshi",
                        "suffix": ""
                    }
                ],
                "year": 1999,
                "venue": "Computational Linguistics",
                "volume": "25",
                "issue": "",
                "pages": "237--265",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Bangalore, Srinivas and Aravind K. Joshi. 1999. Supertagging: an approach to almost parsing. Computational Linguistics, 25:237-265.",
                "links": null
            },
            "BIBREF1": {
                "ref_id": "b1",
                "title": "Procedure for quantitatively comparing the syntactic coverage of English grammars",
                "authors": [
                    {
                        "first": "Shane",
                        "middle": [],
                        "last": "Bergsma",
                        "suffix": ""
                    },
                    {
                        "first": "Colin",
                        "middle": [],
                        "last": "Cherry",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Beijing",
                        "suffix": ""
                    },
                    {
                        "first": "E",
                        "middle": [],
                        "last": "Black",
                        "suffix": ""
                    },
                    {
                        "first": "S",
                        "middle": [],
                        "last": "Abney",
                        "suffix": ""
                    },
                    {
                        "first": "S",
                        "middle": [],
                        "last": "Flickenger",
                        "suffix": ""
                    },
                    {
                        "first": "C",
                        "middle": [],
                        "last": "Gdaniec",
                        "suffix": ""
                    },
                    {
                        "first": "C",
                        "middle": [],
                        "last": "Grishman",
                        "suffix": ""
                    },
                    {
                        "first": "P",
                        "middle": [],
                        "last": "Harrison",
                        "suffix": ""
                    },
                    {
                        "first": "D",
                        "middle": [],
                        "last": "Hindle",
                        "suffix": ""
                    },
                    {
                        "first": "R",
                        "middle": [],
                        "last": "Ingria",
                        "suffix": ""
                    },
                    {
                        "first": "F",
                        "middle": [],
                        "last": "Jelinek",
                        "suffix": ""
                    },
                    {
                        "first": "J",
                        "middle": [],
                        "last": "Klavans",
                        "suffix": ""
                    },
                    {
                        "first": "M",
                        "middle": [],
                        "last": "Liberman",
                        "suffix": ""
                    },
                    {
                        "first": "M",
                        "middle": [],
                        "last": "Marcus",
                        "suffix": ""
                    },
                    {
                        "first": "S",
                        "middle": [],
                        "last": "Roukos",
                        "suffix": ""
                    },
                    {
                        "first": "B",
                        "middle": [],
                        "last": "Santorini",
                        "suffix": ""
                    },
                    {
                        "first": "T",
                        "middle": [],
                        "last": "Strzalkowski",
                        "suffix": ""
                    }
                ],
                "year": 1991,
                "venue": "Proceedings of the 23rd International Conference on Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "306--311",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Bergsma, Shane and Colin Cherry. 2010. Fast and accurate arc filtering for dependency parsing. In Proceedings of the 23rd International Conference on Computational Linguistics (Coling 2010), pages 53-61, Beijing. Black, E., S. Abney, S. Flickenger, C. Gdaniec, C. Grishman, P. Harrison, D. Hindle, R. Ingria, F. Jelinek, J. Klavans, M. Liberman, M. Marcus, S. Roukos, B. Santorini, and T. Strzalkowski. 1991. Procedure for quantitatively comparing the syntactic coverage of English grammars. In Proceedings of the Workshop on Speech and Natural Language, HLT '91, pages 306-311, Pacific Grove, CA.",
                "links": null
            },
            "BIBREF2": {
                "ref_id": "b2",
                "title": "Beam-width prediction for efficient context-free parsing",
                "authors": [
                    {
                        "first": "Nathan",
                        "middle": [],
                        "last": "Bodenstab",
                        "suffix": ""
                    },
                    {
                        "first": "Aaron",
                        "middle": [],
                        "last": "Dunlop",
                        "suffix": ""
                    },
                    {
                        "first": "Keith",
                        "middle": [],
                        "last": "Hall",
                        "suffix": ""
                    },
                    {
                        "first": "Brian",
                        "middle": [],
                        "last": "Roark",
                        "suffix": ""
                    }
                ],
                "year": 2011,
                "venue": "Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "676--681",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Bodenstab, Nathan, Aaron Dunlop, Keith Hall, and Brian Roark. 2011. Beam-width prediction for efficient context-free parsing. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics, pages 440-449, Portland, OR. Bodenstab, Nathan, Kristy Hollingshead, and Brian Roark. 2011. Unary constraints for efficient context-free parsing. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics, pages 676-681, Portland, OR.",
                "links": null
            },
            "BIBREF3": {
                "ref_id": "b3",
                "title": "Joint parsing and alignment with weakly synchronized grammars",
                "authors": [
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Burkett",
                        "suffix": ""
                    },
                    {
                        "first": "John",
                        "middle": [],
                        "last": "Blitzer",
                        "suffix": ""
                    },
                    {
                        "first": "Dan",
                        "middle": [],
                        "last": "Klein",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "Human Language Technologies: The 2010 Annual Conference of the North American Chapter of the Association for Computational Linguistics, HLT '10",
                "volume": "",
                "issue": "",
                "pages": "127--135",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Burkett, David, John Blitzer, and Dan Klein. 2010. Joint parsing and alignment with weakly synchronized grammars. In Human Language Technologies: The 2010 Annual Conference of the North American Chapter of the Association for Computational Linguistics, HLT '10, pages 127-135, Los Angeles, CA.",
                "links": null
            },
            "BIBREF4": {
                "ref_id": "b4",
                "title": "New figures of merit for best-first probabilistic chart parsing",
                "authors": [
                    {
                        "first": "Sharon",
                        "middle": [
                            "A"
                        ],
                        "last": "Caraballo",
                        "suffix": ""
                    },
                    {
                        "first": "Eugene",
                        "middle": [],
                        "last": "Charniak",
                        "suffix": ""
                    }
                ],
                "year": 1997,
                "venue": "Computational Linguistics",
                "volume": "24",
                "issue": "",
                "pages": "275--298",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Caraballo, Sharon A. and Eugene Charniak. 1997. New figures of merit for best-first probabilistic chart parsing. Computational Linguistics, 24:275-298.",
                "links": null
            },
            "BIBREF5": {
                "ref_id": "b5",
                "title": "Joint training of dependency parsing filters through latent support vector machines",
                "authors": [
                    {
                        "first": "Eugene",
                        "middle": [],
                        "last": "Charniak",
                        "suffix": ""
                    },
                    {
                        "first": "Mark",
                        "middle": [],
                        "last": "Johnson",
                        "suffix": ""
                    }
                ],
                "year": 2000,
                "venue": "Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies",
                "volume": "",
                "issue": "",
                "pages": "200--205",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Charniak, Eugene. 2000. A maximum- entropy-inspired parser. In Proceedings of the 1st Conference of the North American Chapter of the Association for Computational Linguistics, pages 132-139, Seattle, WA. Charniak, Eugene and Mark Johnson. 2005. Coarse-to-fine n-best parsing and MaxEnt discriminative reranking. In Proceedings of the 43rd Annual Meeting of the Association for Computational Linguistics (ACL), pages 173-180, Sydney. Cherry, Colin and Shane Bergsma. 2011. Joint training of dependency parsing filters through latent support vector machines. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies, pages 200-205, Toulouse.",
                "links": null
            },
            "BIBREF6": {
                "ref_id": "b6",
                "title": "The importance of supertagging for wide-coverage CCG parsing",
                "authors": [
                    {
                        "first": "Stephen",
                        "middle": [],
                        "last": "Clark",
                        "suffix": ""
                    },
                    {
                        "first": "James",
                        "middle": [
                            "R"
                        ],
                        "last": "Curran",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "Proceedings of COLING",
                "volume": "",
                "issue": "",
                "pages": "282--288",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Clark, Stephen and James R. Curran. 2004. The importance of supertagging for wide-coverage CCG parsing. In Proceedings of COLING, pages 282-288, Geneva.",
                "links": null
            },
            "BIBREF7": {
                "ref_id": "b7",
                "title": "Programming languages and their compilers: Preliminary notes",
                "authors": [
                    {
                        "first": "John",
                        "middle": [],
                        "last": "Cocke",
                        "suffix": ""
                    },
                    {
                        "first": "Jacob",
                        "middle": [
                            "T"
                        ],
                        "last": "Schwartz",
                        "suffix": ""
                    }
                ],
                "year": 1970,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Cocke, John and Jacob T. Schwartz. 1970. Programming languages and their compilers: Preliminary notes. Courant Institute of Mathematical Sciences, New York University.",
                "links": null
            },
            "BIBREF8": {
                "ref_id": "b8",
                "title": "Discriminative training methods for hidden Markov models: Theory and experiments with perceptron algorithms",
                "authors": [
                    {
                        "first": "Michael",
                        "middle": [],
                        "last": "Collins",
                        "suffix": ""
                    }
                ],
                "year": 2002,
                "venue": "Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)",
                "volume": "",
                "issue": "",
                "pages": "1--8",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Collins, Michael. 2002. Discriminative training methods for hidden Markov models: Theory and experiments with perceptron algorithms. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1-8, Philadelphia, PA.",
                "links": null
            },
            "BIBREF9": {
                "ref_id": "b9",
                "title": "Improving the efficiency of a wide-coverage CCG parser",
                "authors": [
                    {
                        "first": "",
                        "middle": [],
                        "last": "Djordjevic",
                        "suffix": ""
                    },
                    {
                        "first": "James",
                        "middle": [
                            "R"
                        ],
                        "last": "Bojan",
                        "suffix": ""
                    },
                    {
                        "first": "Stephen",
                        "middle": [],
                        "last": "Curran",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Clark",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "Proceedings of the 10th International Conference on Parsing Technologies, IWPT '07",
                "volume": "",
                "issue": "",
                "pages": "39--47",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Djordjevic, Bojan, James R. Curran, and Stephen Clark. 2007. Improving the efficiency of a wide-coverage CCG parser. In Proceedings of the 10th International Conference on Parsing Technologies, IWPT '07, pages 39-47, Prague.",
                "links": null
            },
            "BIBREF10": {
                "ref_id": "b10",
                "title": "Vine parsing and minimum risk reranking for speed and precision",
                "authors": [
                    {
                        "first": "Markus",
                        "middle": [],
                        "last": "Dreyer",
                        "suffix": ""
                    },
                    {
                        "first": "David",
                        "middle": [
                            "A"
                        ],
                        "last": "Smith",
                        "suffix": ""
                    },
                    {
                        "first": "Noah",
                        "middle": [
                            "A"
                        ],
                        "last": "Smith",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "Proceedings of the Tenth Conference on Computational Natural Language Learning (CoNLL-X)",
                "volume": "",
                "issue": "",
                "pages": "201--205",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Dreyer, Markus, David A. Smith, and Noah A. Smith. 2006. Vine parsing and minimum risk reranking for speed and precision. In Proceedings of the Tenth Conference on Computational Natural Language Learning (CoNLL-X), pages 201-205, New York, NY.",
                "links": null
            },
            "BIBREF11": {
                "ref_id": "b11",
                "title": "Reducing the grammar constant: an analysis of CYK parsing efficiency",
                "authors": [
                    {
                        "first": "Aaron",
                        "middle": [],
                        "last": "Dunlop",
                        "suffix": ""
                    },
                    {
                        "first": "Nathan",
                        "middle": [],
                        "last": "Bodenstab",
                        "suffix": ""
                    },
                    {
                        "first": "Brian",
                        "middle": [],
                        "last": "Roark",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Dunlop, Aaron, Nathan Bodenstab, and Brian Roark. 2010. Reducing the grammar constant: an analysis of CYK parsing efficiency. Technical report CSLU-2010-02, Oregon Health & Science University, Beaverton, OR.",
                "links": null
            },
            "BIBREF12": {
                "ref_id": "b12",
                "title": "Efficient matrix-encoded grammars and low latency parallelization strategies for CYK",
                "authors": [
                    {
                        "first": "Aaron",
                        "middle": [],
                        "last": "Dunlop",
                        "suffix": ""
                    },
                    {
                        "first": "Nathan",
                        "middle": [],
                        "last": "Bodenstab",
                        "suffix": ""
                    },
                    {
                        "first": "Brian",
                        "middle": [],
                        "last": "Roark",
                        "suffix": ""
                    }
                ],
                "year": 2011,
                "venue": "Proceedings of the 12th International Conference on Parsing Technologies (IWPT)",
                "volume": "",
                "issue": "",
                "pages": "163--174",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Dunlop, Aaron, Nathan Bodenstab, and Brian Roark. 2011. Efficient matrix-encoded grammars and low latency parallelization strategies for CYK. In Proceedings of the 12th International Conference on Parsing Technologies (IWPT), pages 163-174, Dublin.",
                "links": null
            },
            "BIBREF13": {
                "ref_id": "b13",
                "title": "An efficient context-free parsing algorithm",
                "authors": [
                    {
                        "first": "Jay",
                        "middle": [],
                        "last": "Earley",
                        "suffix": ""
                    }
                ],
                "year": 1970,
                "venue": "Communications of the ACM",
                "volume": "6",
                "issue": "8",
                "pages": "451--455",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Earley, Jay. 1970. An efficient context-free parsing algorithm. Communications of the ACM, 6(8):451-455.",
                "links": null
            },
            "BIBREF14": {
                "ref_id": "b14",
                "title": "Parsing with soft and hard constraints on dependency length",
                "authors": [
                    {
                        "first": "Jason",
                        "middle": [],
                        "last": "Eisner",
                        "suffix": ""
                    },
                    {
                        "first": "Noah",
                        "middle": [
                            "A"
                        ],
                        "last": "Smith",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "Proceedings of the Ninth International Workshop on Parsing Technology (IWPT)",
                "volume": "",
                "issue": "",
                "pages": "30--41",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Eisner, Jason and Noah A. Smith. 2005. Parsing with soft and hard constraints on dependency length. In Proceedings of the Ninth International Workshop on Parsing Technology (IWPT), pages 30-41, Vancouver.",
                "links": null
            },
            "BIBREF15": {
                "ref_id": "b15",
                "title": "Speeding up full syntactic parsing by leveraging partial parsing decisions",
                "authors": [
                    {
                        "first": "Elliot",
                        "middle": [],
                        "last": "Glaysher",
                        "suffix": ""
                    },
                    {
                        "first": "Dan",
                        "middle": [],
                        "last": "Moldovan",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "Proceedings of the COLING/ACL 2006 Main Conference Poster Sessions",
                "volume": "",
                "issue": "",
                "pages": "295--300",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Glaysher, Elliot and Dan Moldovan. 2006. Speeding up full syntactic parsing by leveraging partial parsing decisions. In Proceedings of the COLING/ACL 2006 Main Conference Poster Sessions, pages 295-300, Sydney.",
                "links": null
            },
            "BIBREF16": {
                "ref_id": "b16",
                "title": "Comparing and combining finite-state and context-free parsers",
                "authors": [
                    {
                        "first": "Kristy",
                        "middle": [],
                        "last": "Hollingshead",
                        "suffix": ""
                    },
                    {
                        "first": "Seeger",
                        "middle": [],
                        "last": "Fisher",
                        "suffix": ""
                    },
                    {
                        "first": "Brian",
                        "middle": [],
                        "last": "Roark",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "Proceedings of the Human Language Technology Conference and the Conference on Empirical Methods in Natural Language Processing (HLT/EMNLP)",
                "volume": "",
                "issue": "",
                "pages": "787--794",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Hollingshead, Kristy, Seeger Fisher, and Brian Roark. 2005. Comparing and combining finite-state and context-free parsers. In Proceedings of the Human Language Technology Conference and the Conference on Empirical Methods in Natural Language Processing (HLT/EMNLP), pages 787-794, Vancouver.",
                "links": null
            },
            "BIBREF17": {
                "ref_id": "b17",
                "title": "Pipeline iteration",
                "authors": [
                    {
                        "first": "Kristy",
                        "middle": [],
                        "last": "Hollingshead",
                        "suffix": ""
                    },
                    {
                        "first": "Brian",
                        "middle": [],
                        "last": "Roark",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "Proceedings of the 45th Annual Meeting of the Association for Computational Linguistics (ACL)",
                "volume": "",
                "issue": "",
                "pages": "952--959",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Hollingshead, Kristy and Brian Roark. 2007. Pipeline iteration. In Proceedings of the 45th Annual Meeting of the Association for Computational Linguistics (ACL), pages 952-959, Prague.",
                "links": null
            },
            "BIBREF18": {
                "ref_id": "b18",
                "title": "An efficient recognition and syntax analysis algorithm for context-free languages",
                "authors": [
                    {
                        "first": "Tadao",
                        "middle": [],
                        "last": "Kasami",
                        "suffix": ""
                    },
                    {
                        "first": "M",
                        "middle": [
                            "A"
                        ],
                        "last": "Bedford",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Marcus",
                        "suffix": ""
                    },
                    {
                        "first": "P",
                        "middle": [],
                        "last": "Mitchell",
                        "suffix": ""
                    },
                    {
                        "first": "Beatrice",
                        "middle": [],
                        "last": "Mary Ann Marcinkiewicz",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Santorini",
                        "suffix": ""
                    }
                ],
                "year": 1965,
                "venue": "Computational Linguistics",
                "volume": "19",
                "issue": "",
                "pages": "313--330",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kasami, Tadao. 1965. An efficient recognition and syntax analysis algorithm for context-free languages. Technical report AFCRL-65-758, Air Force Cambridge Research Lab, Bedford, MA. Marcus, Mitchell P., Mary Ann Marcinkiewicz, and Beatrice Santorini. 1993. Building a large annotated corpus of English: The Penn treebank. Computational Linguistics, 19:313-330.",
                "links": null
            },
            "BIBREF19": {
                "ref_id": "b19",
                "title": "Non-projective 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": "Proceedings of Human Language Technology Conference and Conference on Empirical Methods in Natural Language Processing (HLT/EMNLP)",
                "volume": "",
                "issue": "",
                "pages": "523--530",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "McDonald, Ryan, Fernando Pereira, Kiril Ribarov, and Jan Hajic. 2005. Non-projective dependency parsing using spanning tree algorithms. In Proceedings of Human Language Technology Conference and Conference on Empirical Methods in Natural Language Processing (HLT/EMNLP), pages 523-530, Vancouver.",
                "links": null
            },
            "BIBREF20": {
                "ref_id": "b20",
                "title": "Constraints on non-projective dependency parsing",
                "authors": [
                    {
                        "first": "Joakim",
                        "middle": [],
                        "last": "Nivre",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "Proceedings of the 11th Conference of the European Chapter of the Association for Computational Linguistics (EACL)",
                "volume": "",
                "issue": "",
                "pages": "73--80",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Nivre, Joakim. 2006. Constraints on non-projective dependency parsing. In Proceedings of the 11th Conference of the European Chapter of the Association for Computational Linguistics (EACL), pages 73-80, Trento.",
                "links": null
            },
            "BIBREF21": {
                "ref_id": "b21",
                "title": "Improved inference for unlexicalized parsing",
                "authors": [
                    {
                        "first": "Slav",
                        "middle": [],
                        "last": "Petrov",
                        "suffix": ""
                    },
                    {
                        "first": "Dan",
                        "middle": [],
                        "last": "Klein",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "Proceedings of Human Language Technologies 2007: The Conference of the North American Chapter of the Association for Computational Linguistics (HLT-NAACL)",
                "volume": "",
                "issue": "",
                "pages": "404--411",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Petrov, Slav and Dan Klein. 2007a. Improved inference for unlexicalized parsing. In Proceedings of Human Language Technologies 2007: The Conference of the North American Chapter of the Association for Computational Linguistics (HLT-NAACL), pages 404-411, Rochester, NY.",
                "links": null
            },
            "BIBREF22": {
                "ref_id": "b22",
                "title": "Learning and inference for hierarchically split PCFGs",
                "authors": [
                    {
                        "first": "Slav",
                        "middle": [],
                        "last": "Petrov",
                        "suffix": ""
                    },
                    {
                        "first": "Dan",
                        "middle": [],
                        "last": "Klein",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "Proceedings of the 22nd National Conference on Artificial Intelligence",
                "volume": "2",
                "issue": "",
                "pages": "1663--1666",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Petrov, Slav and Dan Klein. 2007b. Learning and inference for hierarchically split PCFGs. In Proceedings of the 22nd National Conference on Artificial Intelligence - Volume 2, pages 1663-1666, Vancouver.",
                "links": null
            },
            "BIBREF23": {
                "ref_id": "b23",
                "title": "Learning to parse natural language with maximum entropy models",
                "authors": [
                    {
                        "first": "Adwait",
                        "middle": [],
                        "last": "Ratnaparkhi",
                        "suffix": ""
                    }
                ],
                "year": 1999,
                "venue": "Machine Learning",
                "volume": "34",
                "issue": "",
                "pages": "151--175",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ratnaparkhi, Adwait. 1999. Learning to parse natural language with maximum entropy models. Machine Learning, 34(1-3):151-175.",
                "links": null
            },
            "BIBREF24": {
                "ref_id": "b24",
                "title": "Classifying chart cells for quadratic complexity context-free inference",
                "authors": [
                    {
                        "first": "Brian",
                        "middle": [],
                        "last": "Roark",
                        "suffix": ""
                    },
                    {
                        "first": "Kristy",
                        "middle": [],
                        "last": "Hollingshead",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "Proceedings of the 22nd International Conference on Computational Linguistics (COLING)",
                "volume": "",
                "issue": "",
                "pages": "745--752",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Roark, Brian and Kristy Hollingshead. 2008. Classifying chart cells for quadratic complexity context-free inference. In Proceedings of the 22nd International Conference on Computational Linguistics (COLING), pages 745-752, Manchester.",
                "links": null
            },
            "BIBREF25": {
                "ref_id": "b25",
                "title": "Linear complexity context-free parsing pipelines via chart constraints",
                "authors": [
                    {
                        "first": "Brian",
                        "middle": [],
                        "last": "Roark",
                        "suffix": ""
                    },
                    {
                        "first": "Kristy",
                        "middle": [],
                        "last": "Hollingshead",
                        "suffix": ""
                    }
                ],
                "year": 2009,
                "venue": "Proceedings of Human Language Technologies: The 2009 Annual Conference of the North American Chapter of the Association for Computational Linguistics (HLT-NAACL)",
                "volume": "",
                "issue": "",
                "pages": "647--655",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Roark, Brian and Kristy Hollingshead. 2009. Linear complexity context-free parsing pipelines via chart constraints. In Proceedings of Human Language Technologies: The 2009 Annual Conference of the North American Chapter of the Association for Computational Linguistics (HLT-NAACL), pages 647-655, Boulder, CO.",
                "links": null
            },
            "BIBREF26": {
                "ref_id": "b26",
                "title": "Shallow parsing with conditional random fields",
                "authors": [
                    {
                        "first": "Fei",
                        "middle": [],
                        "last": "Sha",
                        "suffix": ""
                    },
                    {
                        "first": "Fernando",
                        "middle": [],
                        "last": "Pereira",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "Proceedings of HLT-NAACL",
                "volume": "",
                "issue": "",
                "pages": "134--141",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Sha, Fei and Fernando Pereira. 2003. Shallow parsing with conditional random fields. In Proceedings of HLT-NAACL, pages 134-141, Edmonton.",
                "links": null
            },
            "BIBREF27": {
                "ref_id": "b27",
                "title": "Using a maximum entropy-based tagger to improve a very fast vine parser",
                "authors": [
                    {
                        "first": "Anders",
                        "middle": [],
                        "last": "Sogaard",
                        "suffix": ""
                    },
                    {
                        "first": "Jonas",
                        "middle": [],
                        "last": "Kuhn",
                        "suffix": ""
                    }
                ],
                "year": 2009,
                "venue": "Proceedings of the 11th International Conference on Parsing Technologies, IWPT '09",
                "volume": "",
                "issue": "",
                "pages": "206--209",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Sogaard, Anders and Jonas Kuhn. 2009. Using a maximum entropy-based tagger to improve a very fast vine parser. In Proceedings of the 11th International Conference on Parsing Technologies, IWPT '09, pages 206-209, Paris.",
                "links": null
            },
            "BIBREF28": {
                "ref_id": "b28",
                "title": "Better binarization for the CKY parsing",
                "authors": [
                    {
                        "first": "Xinying",
                        "middle": [],
                        "last": "Song",
                        "suffix": ""
                    },
                    {
                        "first": "Shilin",
                        "middle": [],
                        "last": "Ding",
                        "suffix": ""
                    },
                    {
                        "first": "Chin-Yew",
                        "middle": [],
                        "last": "Lin",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "Proceedings of the Conference on Empirical Methods in Natural Language Processing, EMNLP '08",
                "volume": "",
                "issue": "",
                "pages": "167--176",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Song, Xinying, Shilin Ding, and Chin-Yew Lin. 2008. Better binarization for the CKY parsing. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, EMNLP '08, pages 167-176, Honolulu, HI.",
                "links": null
            },
            "BIBREF29": {
                "ref_id": "b29",
                "title": "Sidestepping intractable inference with structured ensemble cascades",
                "authors": [
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Weiss",
                        "suffix": ""
                    },
                    {
                        "first": "Benjamin",
                        "middle": [],
                        "last": "Sapp",
                        "suffix": ""
                    },
                    {
                        "first": "Ben",
                        "middle": [],
                        "last": "Taskar",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "Proceedings of NIPS",
                "volume": "",
                "issue": "",
                "pages": "2415--2423",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Weiss, David, Benjamin Sapp, and Ben Taskar. 2010. Sidestepping intractable inference with structured ensemble cascades. In Proceedings of NIPS, pages 2415-2423, Vancouver.",
                "links": null
            },
            "BIBREF30": {
                "ref_id": "b30",
                "title": "Structured prediction cascades",
                "authors": [
                    {
                        "first": "David",
                        "middle": [],
                        "last": "Weiss",
                        "suffix": ""
                    },
                    {
                        "first": "Benjamin",
                        "middle": [],
                        "last": "Taskar",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "Journal of Machine Learning Research -Proceedings Track",
                "volume": "9",
                "issue": "",
                "pages": "916--923",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Weiss, David and Benjamin Taskar. 2010. Structured prediction cascades. Journal of Machine Learning Research -Proceedings Track, 9:916-923.",
                "links": null
            },
            "BIBREF31": {
                "ref_id": "b31",
                "title": "The Penn Chinese treebank: Phrase structure annotation of a large corpus",
                "authors": [
                    {
                        "first": "Naiwen",
                        "middle": [],
                        "last": "Xue",
                        "suffix": ""
                    },
                    {
                        "first": "Fei",
                        "middle": [],
                        "last": "Xia",
                        "suffix": ""
                    },
                    {
                        "first": "Fu-Dong",
                        "middle": [],
                        "last": "Chiou",
                        "suffix": ""
                    },
                    {
                        "first": "Marta",
                        "middle": [],
                        "last": "Palmer",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "Natural Language Engingeering",
                "volume": "11",
                "issue": "",
                "pages": "207--238",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Xue, Naiwen, Fei Xia, Fu-dong Chiou, and Marta Palmer. 2005. The Penn Chinese treebank: Phrase structure annotation of a large corpus. Natural Language Engingeering, 11:207-238.",
                "links": null
            },
            "BIBREF32": {
                "ref_id": "b32",
                "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
            },
            "BIBREF33": {
                "ref_id": "b33",
                "title": "K-best combination of syntactic parsers",
                "authors": [
                    {
                        "first": "Hui",
                        "middle": [],
                        "last": "Zhang",
                        "suffix": ""
                    },
                    {
                        "first": "Min",
                        "middle": [],
                        "last": "Zhang",
                        "suffix": ""
                    },
                    {
                        "first": "Haizhou",
                        "middle": [],
                        "last": "Chew Lim Tan",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Li",
                        "suffix": ""
                    }
                ],
                "year": 2009,
                "venue": "Proceedings of the 2009 Conference on Empirical Methods in Natural Language Processing",
                "volume": "3",
                "issue": "",
                "pages": "1552--1560",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Zhang, Hui, Min Zhang, Chew Lim Tan, and Haizhou Li. 2009. K-best combination of syntactic parsers. In Proceedings of the 2009 Conference on Empirical Methods in Natural Language Processing: Volume 3, EMNLP '09, pages 1552-1560, Singapore.",
                "links": null
            },
            "BIBREF34": {
                "ref_id": "b34",
                "title": "Chart pruning for fast lexicalised-grammar parsing",
                "authors": [
                    {
                        "first": "Yue",
                        "middle": [],
                        "last": "Zhang",
                        "suffix": ""
                    },
                    {
                        "first": "Byung",
                        "middle": [],
                        "last": "Gyu Ahn",
                        "suffix": ""
                    },
                    {
                        "first": "Stephen",
                        "middle": [],
                        "last": "Clark",
                        "suffix": ""
                    },
                    {
                        "first": "Curt",
                        "middle": [],
                        "last": "Van Wyk",
                        "suffix": ""
                    },
                    {
                        "first": "James",
                        "middle": [
                            "R"
                        ],
                        "last": "Curran",
                        "suffix": ""
                    },
                    {
                        "first": "Laura",
                        "middle": [
                            "Rimell"
                        ],
                        "last": "",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "Proceedings of the 23rd International Conference on Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "1472--1479",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Zhang, Yue, Byung Gyu Ahn, Stephen Clark, Curt Van Wyk, James R. Curran, and Laura Rimell. 2010. Chart pruning for fast lexicalised-grammar parsing. In Proceedings of the 23rd International Conference on Computational Linguistics, pages 1472-1479, Beijing.",
                "links": null
            }
        },
        "ref_entries": {
            "FIGREF0": {
                "text": "Begin (a), End (b), Unary (c), and the combination of the three (d) type of constraints for the dynamic programming chart used to parse As usual, the real-estate market had overreacted with a left-binarized grammar (seeFigure 1). Black denotes \"closed\" cells, white cells are \"open,\" and gray cells are only open to a restricted population (gray cells closed by E constraints only allow incomplete edges; gray cells closed by U constraints only allow POS tags).",
                "num": null,
                "uris": null,
                "type_str": "figure"
            },
            "FIGREF1": {
                "text": "e) 18: return \u03b1 of work in each case. The amount of work for each case is related to how the CYK and CONSTRAINEDCYK algorithms performs their search. Each cell (b, e) in the chart spans the substring w b . . . w e , and building non-terminal categories in that cell involves combining non-terminal categories (via rules in the context-free grammar) found in cells spanning adjacent substrings w b . . . w m and w m+1 . . . w e . The substring w b . . . w e can be as large as the entire sentence, requiring a search over O(N) possible midpoint words w m . This accounts for the linear amount of work in these case 3, open, cells.",
                "num": null,
                "uris": null,
                "type_str": "figure"
            },
            "FIGREF2": {
                "text": "Tagger precision/recall tradeoff of B, E, and U on the development set for English (a) and Chinese (b).",
                "num": null,
                "uris": null,
                "type_str": "figure"
            },
            "FIGREF3": {
                "text": "English development set results (WSJ Section 24) applying global high precision (GHP), sentence-level high precision (HP), and unary constraints with the CONSTRAINEDCYK algorithm. We sweep over multiple values of \u03bb in (a) and plot results in (b), (c), and (d) with the optimal value for each constraint found in (a). F-measure accuracy in (b) is computed over binned sentence lengths.Figure (d)plots the same data as (c), but zoomed in.",
                "num": null,
                "uris": null,
                "type_str": "figure"
            },
            "FIGREF4": {
                "text": "Figure (d) plots the same data as (c), but zoomed in.",
                "num": null,
                "uris": null,
                "type_str": "figure"
            },
            "TABREF3": {
                "text": "If |B| \u2264 \u03bb for some \u03bb, then |C 2 | + |C 3 | \u2264 \u03bbN. For a string of length N and some w b \u2208 B, there are at most N substrings w b . . . w e to consider, hence O(N) chart cells for each word w b \u2208 B. Because |B| \u2264 \u03bb, then there are at most \u03bbN cells (b, e) \u2208 C 1 and |C 2 | + |C 3 | \u2264 \u03bbN.",
                "num": null,
                "type_str": "table",
                "content": "<table><tr><td>Lemma 2</td></tr><tr><td>Proof</td></tr></table>",
                "html": null
            },
            "TABREF4": {
                "text": "displays word statistics from the training sections of the Penn English treebank",
                "num": null,
                "type_str": "table",
                "content": "<table/>",
                "html": null
            },
            "TABREF5": {
                "text": "Statistics on extracted word classes for English (Sections 2-21 of the Penn WSJ treebank) and Chinese (articles 1-270 and 400-1151 of the Penn Chinese treebank).",
                "num": null,
                "type_str": "table",
                "content": "<table><tr><td/><td colspan=\"2\">Corpus totals</td><td colspan=\"2\">Begin class</td><td colspan=\"2\">End class</td><td colspan=\"2\">Unary class</td></tr><tr><td/><td>Strings</td><td>Words</td><td>B</td><td>B</td><td>E</td><td>E</td><td>U</td><td>U</td></tr><tr><td>English</td><td/><td/><td/><td/><td/><td/><td/></tr><tr><td>Count</td><td>39,832</td><td colspan=\"7\">950,028 430,841 439,558 223,544 646,855 105,973 844,055</td></tr><tr><td>Percent</td><td/><td/><td>49.5</td><td>50.5</td><td>25.7</td><td>74.3</td><td>11.2</td><td>88.8</td></tr><tr><td>Chinese</td><td/><td/><td/><td/><td/><td/><td/></tr><tr><td>Count</td><td>18,086</td><td colspan=\"7\">493,708 188,612 269,000 165,591 292,021 196,732 296,976</td></tr><tr><td>Percent</td><td/><td/><td>41.2</td><td>58.8</td><td>36.2</td><td>63.8</td><td>39.9</td><td>60.1</td></tr></table>",
                "html": null
            },
            "TABREF6": {
                "text": "Tagger features for B, E, and U.",
                "num": null,
                "type_str": "table",
                "content": "<table><tr><td>LEX</td><td>ORTHO</td><td>POS</td></tr></table>",
                "html": null
            },
            "TABREF7": {
                "text": "Tagging accuracy on the respective development sets (WSJ Section 24 for English and Penn Chinese Treebank articles 301-325 for Chinese) for binary classes B, E, and U, for various Markov orders.",
                "num": null,
                "type_str": "table",
                "content": "<table><tr><td>Tagging Task</td><td colspan=\"3\">Markov order</td></tr><tr><td/><td>0</td><td>1</td><td>2</td></tr><tr><td>English</td><td/><td/></tr><tr><td colspan=\"4\">B (no multi-word constituent begin) 96.7 96.9 96.9</td></tr><tr><td>E (no multi-word constituent end)</td><td colspan=\"3\">97.3 97.3 97.3</td></tr><tr><td>U (no span-1 unary constituent)</td><td colspan=\"3\">98.3 98.3 98.3</td></tr><tr><td>Chinese</td><td/><td/></tr><tr><td colspan=\"4\">B (no multi-word constituent begin) 94.8 95.4 95.2</td></tr><tr><td>E (no multi-word constituent end)</td><td colspan=\"3\">96.2 96.4 96.6</td></tr><tr><td>U (no span-1 unary constituent)</td><td colspan=\"3\">95.9 96.2 96.3</td></tr></table>",
                "html": null
            },
            "TABREF8": {
                "text": "English development set results (WSJ Section 24) for the CONSTRAINEDCYK algorithm with both left-and right-binarized Markov order-2 grammars under various individual and combined constraints.",
                "num": null,
                "type_str": "table",
                "content": "<table><tr><td/><td>Constraints</td><td>F 1</td><td>Precision</td><td colspan=\"2\">Recall Seconds</td><td>Speed-up</td></tr><tr><td/><td>None (baseline CYK)</td><td>71.5</td><td>74.5</td><td>68.8</td><td>451</td><td/></tr><tr><td/><td>GHP(40)</td><td>75.3</td><td>78.6</td><td>72.3</td><td>46</td><td>9.8x</td></tr><tr><td>Right-binarized grammar</td><td>HP(0.95) Quad(4) Linear(12) Unary(40) HP(0.95) + Quad(4) HP(0.95) + Linear(12) GHP(40) + Quad(4) GHP(40) + Linear(12) GHP(40) + Unary(40)</td><td>74.6 73.8 72.4 72.0 74.6 74.4 75.3 75.1 75.7</td><td>77.8 77.0 75.4 75.4 77.8 77.6 78.5 78.4 79.4</td><td>71.7 70.9 69.6 68.9 71.7 71.5 72.3 72.1 72.4</td><td>50 70 106 386 48 48 45 44 34</td><td>8.9x 6.4x 4.3x 1.2x 9.5x 9.5x 10.0x 10.2x 13.4x</td></tr><tr><td/><td colspan=\"2\">GHP(40) + Unary(40) + Quad(4) 75.8</td><td>79.5</td><td>72.4</td><td>33</td><td>13.9x</td></tr><tr><td/><td>None (baseline CYK)</td><td>71.7</td><td>74.5</td><td>69.1</td><td>774</td><td/></tr><tr><td/><td>GHP(40)</td><td>75.4</td><td>78.5</td><td>72.5</td><td>66</td><td>11.2x</td></tr><tr><td/><td>HP(0.95)</td><td>74.9</td><td>77.9</td><td>72.1</td><td>75</td><td>10.3x</td></tr><tr><td>Left-binarized grammar</td><td>Quad(4) Linear(24) Unary(40) HP(0.95) + Quad(4) HP(0.95) + Linear(24) GHP(40) + Quad(4) GHP(40) + Linear(24) GHP(40) + Unary(40)</td><td>74.0 71.7 71.9 74.9 74.7 75.4 75.2 75.7</td><td>77.0 74.5 75.2 78.0 77.8 78.5 78.4 79.3</td><td>71.2 69.1 69.0 72.1 71.9 72.5 72.3 72.5</td><td>99 448 607 69 71 62 62 37</td><td>7.8x 1.7x 1.3x 11.2x 11.0x 12.6x 12.6x 20.9x</td></tr><tr><td/><td colspan=\"2\">GHP(40) + Unary(40) + Quad(4) 75.7</td><td>79.3</td><td>72.5</td><td>37</td><td>20.9x</td></tr></table>",
                "html": null
            },
            "TABREF9": {
                "text": "English test set results (WSJ Section 23) for the CONSTRAINEDCYK algorithm with both left-and right-binarized Markov order-2 grammars.",
                "num": null,
                "type_str": "table",
                "content": "<table><tr><td/><td>Constraints</td><td>F 1</td><td colspan=\"4\">Precision Recall Seconds Speed-up</td></tr><tr><td>Right</td><td colspan=\"2\">None (baseline CYK) 71.7 Unary(40) 72.1 GHP(40) 75.8</td><td>74.6 75.5 79.0</td><td>69.0 69.0 72.8</td><td>628 525 75</td><td>1.2x 8.4x</td></tr><tr><td/><td colspan=\"2\">GHP(40) + Unary(40) 76.1</td><td>79.8</td><td>72.7</td><td>57</td><td>11.0x</td></tr><tr><td/><td colspan=\"2\">None (baseline CYK) 72.0</td><td>74.8</td><td>69.4</td><td>1,063</td><td/></tr><tr><td>Left</td><td>Unary(40) GHP(40)</td><td>72.4 76.1</td><td>75.8 79.3</td><td>69.4 73.2</td><td>910 106</td><td>1.2x 10.1x</td></tr><tr><td/><td colspan=\"2\">GHP(40) + Unary(40) 76.4</td><td>80.0</td><td>73.1</td><td>60</td><td>17.9x</td></tr><tr><td colspan=\"2\">Table 6</td><td/><td/><td/><td/><td/></tr><tr><td colspan=\"7\">Chinese test set results (PCTB Sections 271-300) for the CONSTRAINEDCYK algorithm with both</td></tr><tr><td colspan=\"4\">left-and right-binarized Markov order-2 grammars.</td><td/><td/><td/></tr><tr><td/><td>Constraints</td><td>F 1</td><td colspan=\"4\">Precision Recall Seconds Speed-up</td></tr><tr><td>Right</td><td colspan=\"2\">None (baseline CYK) 60.5 Unary(20) 62.3 GHP(20) 66.9</td><td>64.6 67.6 71.4</td><td>56.9 57.8 63.0</td><td>157 141 17</td><td>1.1x 9.1x</td></tr><tr><td/><td colspan=\"2\">GHP(20) + Unary(20) 68.9</td><td>74.4</td><td>64.1</td><td>15</td><td>10.2x</td></tr><tr><td/><td colspan=\"2\">None (baseline CYK) 60.4</td><td>64.5</td><td>56.9</td><td>269</td><td/></tr><tr><td>Left</td><td>Unary(20) GHP(20)</td><td>62.1 66.0</td><td>67.2 70.5</td><td>57.8 62.1</td><td>234 33</td><td>1.2x 8.2x</td></tr><tr><td/><td colspan=\"2\">GHP(20) + Unary(20) 68.0</td><td>73.5</td><td>63.2</td><td>23</td><td>11.7x</td></tr></table>",
                "html": null
            }
        }
    }
}