{ "paper_id": "J11-4009", "header": { "generated_with": "S2ORC 1.0.0", "date_generated": "2023-01-19T03:05:53.959632Z" }, "title": "Splittability of Bilexical Context-Free Grammars is Undecidable", "authors": [ { "first": "Mark-Jan", "middle": [], "last": "Nederhof", "suffix": "", "affiliation": { "laboratory": "", "institution": "University of St", "location": { "addrLine": "Andrews, North Haugh, St. Andrews, Fife", "postCode": "KY16 9SX", "country": "Scotland" } }, "email": "markjan.nederhof@gmail.com" }, { "first": "Giorgio", "middle": [], "last": "Satta", "suffix": "", "affiliation": { "laboratory": "", "institution": "University of St", "location": { "addrLine": "Andrews, North Haugh, St. Andrews, Fife", "postCode": "KY16 9SX", "country": "Scotland" } }, "email": "satta@dei.unipd.it.submission" } ], "year": "", "venue": null, "identifiers": {}, "abstract": "Bilexical context-free grammars (2-LCFGs) have proved to be accurate models for statistical natural language parsing. Existing dynamic programming algorithms used to parse sentences under these models have running time of O(|w| 4), where w is the input string. A 2-LCFG is splittable if the left arguments of a lexical head are always independent of the right arguments, and vice versa. When a 2-LCFGs is splittable, parsing time can be asymptotically improved to O(|w| 3). Testing this property is therefore of central interest to parsing efficiency. In this article, however, we show the negative result that splittability of 2-LCFGs is undecidable.", "pdf_parse": { "paper_id": "J11-4009", "_pdf_hash": "", "abstract": [ { "text": "Bilexical context-free grammars (2-LCFGs) have proved to be accurate models for statistical natural language parsing. Existing dynamic programming algorithms used to parse sentences under these models have running time of O(|w| 4), where w is the input string. A 2-LCFG is splittable if the left arguments of a lexical head are always independent of the right arguments, and vice versa. When a 2-LCFGs is splittable, parsing time can be asymptotically improved to O(|w| 3). Testing this property is therefore of central interest to parsing efficiency. In this article, however, we show the negative result that splittability of 2-LCFGs is undecidable.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Abstract", "sec_num": null } ], "body_text": [ { "text": "Bilexical context-free grammars, or 2-LCFGs for short, are specialized context-free grammars where each nonterminal is associated with a terminal symbol representing a lexical element of the language of interest. Furthermore, no more than two symbols can be used in the right-hand side of a rule, and the terminal symbol associated with the lefthand side of a rule must also occur on the right-hand side. In this way, 2-LCFGs are able to specify syntactic constraints as well as lexically specific preferences that influence the combination of predicates with their arguments or modifiers. Models based on 2-LCFGs have therefore been of central interest in statistical natural language parsing, as they allow selection of high-quality parse trees. One can in fact see 2-LCFGs as abstract models of the head automata of Alshawi (1996) , the probabilistic projective dependency grammars of Eisner (1996) , and the head-driven statistical models of Charniak (2001) and Collins (2003) .", "cite_spans": [ { "start": 819, "end": 833, "text": "Alshawi (1996)", "ref_id": "BIBREF0" }, { "start": 888, "end": 901, "text": "Eisner (1996)", "ref_id": "BIBREF4" }, { "start": 946, "end": 961, "text": "Charniak (2001)", "ref_id": "BIBREF2" }, { "start": 966, "end": 980, "text": "Collins (2003)", "ref_id": "BIBREF3" } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1." }, { "text": "Parsing algorithms based on 2-LCFGs can be very efficient. In the general case, existing dynamic programming algorithms have running time of O(|w| 4 ), where w is the input string. (In this article we disregard complexity factors that depend on the input grammar, which we will consider to be constants.) In cases in which, for each (lexical) head, the two processes of generating its left and right arguments are, to some extent, independent one of the other, parsing based on 2-LCFGs can be asymptotically improved to O(|w| 3 ). The reader is referred to Eisner and Satta (1999) for a detailed presentation of these computational results.", "cite_spans": [ { "start": 557, "end": 580, "text": "Eisner and Satta (1999)", "ref_id": "BIBREF5" } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1." }, { "text": "In the literature, this condition on independence between left and right arguments of each head has been called splittability (Eisner 1997; Eisner and Satta 1999) . Testing for splittability on an input 2-LCFG is therefore of central interest to parsing efficiency. The computability of this test has never been investigated, however.", "cite_spans": [ { "start": 126, "end": 139, "text": "(Eisner 1997;", "ref_id": "BIBREF5" }, { "start": 140, "end": 162, "text": "Eisner and Satta 1999)", "ref_id": "BIBREF5" } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1." }, { "text": "In this article splittability is defined for 2-LCFGs in terms of equivalence to another grammar in which independence between left and right arguments of each head is ensured by a simple syntactic restriction. This restriction is called split form. Informally, a 2-LCFG is in split form if it can be factorized into individual subgrammars, one for each head, and each subgrammar produces the left and the right arguments of its head through two derivation processes, one happening strictly after the other.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1." }, { "text": "One may believe that a necessary and sufficient condition for splittability is that a 2-LCFG does not allow recursive structures that alternately generate left (L) and right (R) arguments of some head a. These structures could well result in subderivations producing sequences of the form L n aR n , for any n \u2265 0, which would appear to preclude the application of the O(|w| 3 ) algorithm.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1." }, { "text": "This situation, however, does not mean in general that the grammar is not splittable. Although a subset of the rules in a grammar may generate structures such as those just discussed, there may be additional rules that make the observed dependencies between left and right arguments irrelevant. In fact, splittability of a 2-LCFG is undecidable, as will be shown in this article.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1." }, { "text": "Our result is based on the fact that it is undecidable whether a linear context-free grammar with a center marker (to be defined later) generates a regular language. This fact is originally proved in this article, and does not follow from the weaker result stating the undecidability of regularity of (general) linear context-free languages, which is well known in the formal language literature (Hopcroft and Ullman 1979, exercise 8.10a, page 214) and which is originally due to Hunt III and Rosenkrantz (1974) .", "cite_spans": [ { "start": 396, "end": 448, "text": "(Hopcroft and Ullman 1979, exercise 8.10a, page 214)", "ref_id": null }, { "start": 480, "end": 511, "text": "Hunt III and Rosenkrantz (1974)", "ref_id": "BIBREF7" } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1." }, { "text": "The remaining part of this article is organized as follows. In Section 2 we present some preliminary background, and in Section 3 we define 2-LCFGs and the notion of splittability. In Section 4 we prove the main result of this article, and draw some conclusions in Section 5.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1." }, { "text": "In this article we assume the reader is familiar with the notions of context-free grammar, Turing machine, and undecidability (see, e.g., Hopcroft and Ullman 1979) . We briefly summarize the adopted notation now.", "cite_spans": [ { "start": 138, "end": 163, "text": "Hopcroft and Ullman 1979)", "ref_id": "BIBREF6" } ], "ref_spans": [], "eq_spans": [], "section": "Preliminaries", "sec_num": "2." }, { "text": "A context-free grammar (CFG) is a 4-tuple G = (\u03a3, N, S, R) , where \u03a3 is a finite set of terminals, N is a finite set of nonterminals, disjoint from \u03a3 and including the start symbol S, and R is a finite set of rules. Each rule has the form A \u2192 \u03b1, where A \u2208 N and \u03b1 \u2208 (\u03a3 \u222a N) * . A CFG is called linear if each rule A \u2192 \u03b1 has at most one nonterminal in the right-hand side \u03b1.", "cite_spans": [ { "start": 46, "end": 58, "text": "(\u03a3, N, S, R)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Preliminaries", "sec_num": "2." }, { "text": "We associate with G a binary relation called rewrite and denoted by the symbol \u21d2 G , defined such that \u03b3A\u03b3 \u21d2 G \u03b3\u03b1\u03b3 if A \u2192 \u03b1 is a rule in R and \u03b3, \u03b3 \u2208 (\u03a3 \u222a N) * . We drop subscript G from \u21d2 G whenever it is understood from the context. The reflexive and transitive closure of \u21d2 is denoted as \u21d2 * . The language generated by G is defined as L(G) = {w \u2208 \u03a3 * | S \u21d2 * w}.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Preliminaries", "sec_num": "2." }, { "text": "We now introduce a special class of CFGs that will play a central role in the proofs in this article. Assume a distinguished symbol # \u2208 \u03a3, which we will refer to as a center marker. The class of linear CFGs with center marker #, or lin-CFG(#) for short, is the class of CFGs in which each rule either has the form A \u2192 # or the form A \u2192 uBv, where A, B \u2208 N and u, v \u2208 (\u03a3 \\ {#}) * , where symbol \"\\\" denotes set difference. We say a grammar in lin-CFG(#) is in binary form if the total length of u and v in rules A \u2192 uBv is at most 1. It is not difficult to see that there is a language-preserving transformation of grammars in lin-CFG(#) to binary form, as suggested by the following example.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Preliminaries", "sec_num": "2." }, { "text": "Let \u03a3 = {a, b, #}. One member of lin-CFG(#) is the CFG G defined by the rules:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 1", "sec_num": null }, { "text": "S \u2192 a S a, S \u2192 a S b, S \u2192 b S a, S \u2192 b S b, S \u2192 #. For this grammar, strings in L(G) have the form u#v, with u \u2208 (\u03a3 \\ {#}) * and v \u2208 (\u03a3 \\ {#}) * having the same length.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 1", "sec_num": null }, { "text": "A rule such as S \u2192 aSb can be replaced by a pair of rules in binary form, for example S \u2192 aA and A \u2192 Sb, where A is a new nonterminal.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 1", "sec_num": null }, { "text": "We start this section with the definition of 2-LCFG, which is based on Eisner and Satta (1999) . Let N D be a finite alphabet whose symbols will be called delexicalized nonterminals. We combine N D with a set \u03a3 of terminal symbols as follows: S, R) . Every rule in R has one of the following five forms:", "cite_spans": [ { "start": 71, "end": 94, "text": "Eisner and Satta (1999)", "ref_id": "BIBREF5" }, { "start": 243, "end": 248, "text": "S, R)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": "N D (\u03a3) = {A[a] | A \u2208 N D , a \u2208 \u03a3}. A bilexical context-free grammar is a CFG G = (\u03a3, N D (\u03a3) \u222a {S},", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": "r S \u2192 A[a]; r A[a] \u2192 B[b] C[a]; r A[a] \u2192 B[a] C[c]; r A[a] \u2192 B[a]; r A[a] \u2192 a.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": "The nonterminal occurrences C [a] and B [a] in the second and third rules, respectively, and the nonterminal occurrence B [a] in the fourth rule will be referred to as head child occurrences. Notice that the head child of a rule is always associated with the same terminal as the left-hand-side nonterminal. The nonterminal occurrence A [a] in the first rule, and the nonterminal occurrences B [b] and C [c] in the second and third rules, respectively, will be referred to as maximal projection occurrences. Observe how in a parse tree generated by a 2-LCFG, each occurrence of a lexical element (represented as a terminal symbol) is also part of several head child occurrences of nonterminals above it, up to some unique maximal projection occurrence. We assume that the head child occurrence in a rule is always marked within the rule itself, in order to disambiguate cases in which the head child and the maximal projection share the same terminal (a = b in the second rule or a = c in the third). 1 Let G = (\u03a3, N, S, R) be a 2-LCFG and choose some A [a] \u2208 N that occurs as maximal projection in some rule in R. We now define a grammar G (A[a] ", "cite_spans": [ { "start": 30, "end": 33, "text": "[a]", "ref_id": null }, { "start": 40, "end": 43, "text": "[a]", "ref_id": null }, { "start": 122, "end": 125, "text": "[a]", "ref_id": null }, { "start": 337, "end": 340, "text": "[a]", "ref_id": null }, { "start": 394, "end": 397, "text": "[b]", "ref_id": null }, { "start": 404, "end": 407, "text": "[c]", "ref_id": null }, { "start": 1001, "end": 1002, "text": "1", "ref_id": null }, { "start": 1054, "end": 1057, "text": "[a]", "ref_id": null }, { "start": 1141, "end": 1146, "text": "(A[a]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": ") = (\u03a3 (A[a]) , N (A[a]) , A[a], R (A[a]) ) in lin-CFG(a).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": "The main idea here is that G (A[a] ) captures all descending paths in parse trees of G from any maximal projection occurrence of A[a] down to a, treating the maximal projection occurrences of G's nonterminals to the left and right of these paths as terminal symbols of G (A[a] ) . Each such maximal projection nonterminal B [b] , when treated as a terminal, will be denoted as B [b] . The start symbol is A[a] and the rule set R (A[a] ) is specified as follows:", "cite_spans": [ { "start": 29, "end": 34, "text": "(A[a]", "ref_id": null }, { "start": 271, "end": 276, "text": "(A[a]", "ref_id": null }, { "start": 324, "end": 327, "text": "[b]", "ref_id": null }, { "start": 379, "end": 382, "text": "[b]", "ref_id": null }, { "start": 429, "end": 434, "text": "(A[a]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": "r D[a] \u2192 B[b] C[a] is in R (A[a]) for each rule D[a] \u2192 B[b] C[a] in R; r D[a] \u2192 B[a] C[c] is in R (A[a]) for each rule D[a] \u2192 B[a] C[c] in R; r D[a] \u2192 B[a] is in R (A[a]) for each rule D[a] \u2192 B[a] in R; r D[a] \u2192 a is in R (A[a]) for each rule D[a] \u2192 a in R.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": "Grammar G (A[a] ) might contain useless rules, that is, rules that never appear in a derivation of a string of the generated language, but this is irrelevant to the development of the results in this article.", "cite_spans": [ { "start": 10, "end": 15, "text": "(A[a]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": "We now introduce an equivalence relation on 2-LCFGs, which will be used later in the definition of splittability. As we will see, our equivalence relation is stronger than the usual weak equivalence between grammars, where the latter only requires that the languages generated by two grammars be the same. In addition to weak equivalence, we demand that two 2-LCFGs establish the same predicate-argument dependencies between lexical elements in the generated sentences, as will be explained here.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Bilexical CFGs and Splittability", "sec_num": "3." }, { "text": "Two 2-LCFGs G 1 and G 2 are d-equivalent if the following conditions are all satisfied: generate the same languages.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Definition 1", "sec_num": null }, { "text": "If two 2-LCFGs G 1 and G 2 are d-equivalent, then L(G 1 ) = L(G 2 ).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Lemma 1", "sec_num": null }, { "text": "We show the stronger statement that, for each maximal projection occurrence A[a] from G 1 and G 2 (item 1 in Definition 1) and for each w \u2208 \u03a3 * , we have A[a] \u21d2 * G 1 w if and only if A[a] \u21d2 * G 2 w. The statement of the lemma easily follows from item 2 in Definition 1. We proceed by induction on |w|. Assume now |w| > 1. If A[a] \u21d2 * G 1 w, there must be a \"head-driven\" derivation rewriting maximal projection occurrence A[a] into a through a chain of head child nonterminal occurrences. More precisely, we can write:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Assume |w| = 1, w = a. If A[a] \u21d2 * G 1 a, then A[a] \u21d2 * G (A[a]", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "EQUATION", "cite_spans": [], "ref_spans": [], "eq_spans": [ { "start": 0, "end": 8, "text": "EQUATION", "ref_id": "EQREF", "raw_str": "A[a] \u21d2 * G 1 B 1 [b 1 ] \u2022 \u2022 \u2022 B l [b l ]aC 1 [c 1 ] \u2022 \u2022 \u2022 C r [c r ] \u21d2 * G 1 uaC 1 [c 1 ] \u2022 \u2022 \u2022 C r [c r ] \u21d2 * G 1 uav = w", "eq_num": "(1)" } ], "section": "Proof", "sec_num": null }, { "text": "with l, r \u2265 0, l + r > 0 (because |w| > 1), and the indicated occurrence of a in uav is generated from A[a] through a chain of rule applications always rewriting the head child of the previous rule and generating the maximal projection occurrences", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "B i [b i ], 1 \u2264 i \u2264 l, and C j [c j ], 1 \u2264 j \u2264 r. Due to Equation (1) we have A[a] \u21d2 * G (A[a]) 1 B 1 [b 1 ] \u2022 \u2022 \u2022 B l [b l ]aC 1 [c 1 ] \u2022 \u2022 \u2022 C r [c r ] and from item 3 in Definition 1 we have A[a] \u21d2 * G (A[a]) 2 B 1 [b 1 ] \u2022 \u2022 \u2022 B l [b l ]aC 1 [c 1 ] \u2022 \u2022 \u2022 C r [c r ]", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": ". We thus con-", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "clude that A[a] \u21d2 * G 2 B 1 [b 1 ] \u2022 \u2022 \u2022 B l [b l ]aC 1 [c 1 ] \u2022 \u2022 \u2022 C r [c r ]", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": ". From Equation (1) we can also see that there must be strings", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "u i , 1 \u2264 i \u2264 l and v j , 1 \u2264 j \u2264 r, such that B i [b i ] \u21d2 * G 1 u i and C j [b j ] \u21d2 * G 1 v j , where u 1 \u2022 \u2022 \u2022 u l = u and v 1 \u2022 \u2022 \u2022 v r = v. Because each B i [b i ] and each C j [c j ]", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "is a maximal projection occurrence, we can apply the inductive hypothesis and conclude that B i [ ", "cite_spans": [ { "start": 96, "end": 97, "text": "[", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "b i ] \u21d2 * G 2 u i and C j [b j ] \u21d2 * G 2 v j , 1 \u2264 i \u2264 l and 1 \u2264 j \u2264 r.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Putting together all of this, we have", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "A[a] \u21d2 * G 2 u 1 \u2022 \u2022 \u2022 u l av 1 \u2022 \u2022 \u2022 v r = w. With a similar argument we can show that A[a] \u21d2 * G 2 w implies A[a] \u21d2 * G 1 w.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Besides enforcing the weak equivalence between two 2-LCFGs, the d-equivalence relation guarantees that the grammars establish the same dependencies between pairs of lexical elements in the generated sentences. To explain this, we borrow subsequently the notion of dependency structure from dependency grammars.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Let G be a 2-LCFG and let t be a parse tree assigned by G to a string w \u2208 \u03a3 * . We can associate with t a dependency structure, by considering all rule occurrences in t that link two lexical elements from w. It is not difficult to see that if two 2-LCFGs G 1 and G 2 are d-equivalent, then the sets of dependency structures they assign to strings in the common language (via the set of parse trees as sketched above) are identical.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Consider the 2-LCFG G 1 defined by the rules:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 2", "sec_num": null }, { "text": "S \u2192 A[a], A[a] \u2192 a, A[a] \u2192 B[b] A[a], B[b] \u2192 b, A[a] \u2192 C[c] A[a], C[c] \u2192 c, A[a] \u2192 A[a] D[d], D[d] \u2192 d, A[a] \u2192 A[a] E[e],", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 2", "sec_num": null }, { "text": "E[e] \u2192 e; and the 2-LCFG G 2 defined by the rules:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 2", "sec_num": null }, { "text": "S \u2192 A[a], A [a] \u2192 a, A[a] \u2192 B[b] A[a], B[b] \u2192 b, A[a] \u2192 C[c] A[a], C[c] \u2192 c, A[a] \u2192 A [a], D[d] \u2192 d, A [a] \u2192 A [a] D[d], E[e] \u2192 e, A [a] \u2192 A [a] E[e].", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 2", "sec_num": null }, { "text": "G 1 and G 2 are d-equivalent, and thus generate the same language by Lemma 1. This language consists of all strings of the form uav, where u \u2208 {b, c} * and v \u2208 {d, e} * . Furthermore, the set of dependency structures associated by G 1 and G 2 to any of the strings they can generate are the same. Figure 1 shows one instance of such a correspondence. Note that in addition to the tree in Figure 1(a) , there are two more trees generated by grammar G 1 that correspond to the dependency structure in Figure 1(c) . We conclude this section with the definition of splittability, which is central to this article. We first introduce a special form for 2-LCFGs, which we call split form. The intuition is that a 2-LCFG is in split form if, for each maximal projection nonterminal occurrence A [a] , all arguments on the left are generated first, followed by the generation of all arguments on the right.", "cite_spans": [ { "start": 788, "end": 791, "text": "[a]", "ref_id": null } ], "ref_spans": [ { "start": 297, "end": 305, "text": "Figure 1", "ref_id": "FIGREF0" }, { "start": 388, "end": 399, "text": "Figure 1(a)", "ref_id": "FIGREF0" }, { "start": 499, "end": 510, "text": "Figure 1(c)", "ref_id": "FIGREF0" } ], "eq_spans": [], "section": "Example 2", "sec_num": null }, { "text": "A 2-LCFG G = (\u03a3, N D (\u03a3) \u222a {S}, S, R)", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Definition 2", "sec_num": null }, { "text": "is in split form if, for each maximal projection occurrence of a nonterminal A[a] \u2208 N D (\u03a3), the nonterminals in G (A[a] ", "cite_spans": [], "ref_spans": [ { "start": 115, "end": 120, "text": "(A[a]", "ref_id": null } ], "eq_spans": [], "section": "Definition 2", "sec_num": null }, { "text": "= {A [a]}.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Definition 2", "sec_num": null }, { "text": "The importance of 2-LCFGs in split form is that they allow parsing in time O(|w| 3 ), which is independent of the size of G assuming N D is fixed. This contrasts with the time complexity O(|w| 4 ) for arbitrary 2-LCFGs.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Definition 2", "sec_num": null }, { "text": "We say a 2-LCFG G 1 is splittable if there is a 2-LCFG G 2 in split form such that G 1 and G 2 are d-equivalent. Grammar G 1 from Example 2 is splittable, because it is d-equivalent to grammar G 2 in the same example, and the latter is in split form.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Definition 2", "sec_num": null }, { "text": "Consider the 2-LCFG defined by the following rules:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 3", "sec_num": null }, { "text": "S \u2192 A[a], A[a] \u2192 a, A[a] \u2192 B[b] A [a], B[b] \u2192 b, A [a] \u2192 A[a] C[c], C[c] \u2192 c.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 3", "sec_num": null }, { "text": "Note that there is an equal number of arguments on either side of the head a. No 2-LCFG in split form can achieve this dependency, and therefore this grammar is not splittable.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 3", "sec_num": null }, { "text": "We can now formally prove that if a 2-LCFG is splittable, then the left arguments of each head are independent of its right arguments, and vice versa, in the sense that only a finite amount of information can be passed between the two sides.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Example 3", "sec_num": null }, { "text": "Let G be a 2-LCFG. G is splittable if and only if, for each maximal projection occurrence A[a] from G, the lin-CFG(a) G (A[a] ) generates a regular language. . For each such choice, the set of strings u is clearly regular, as it is generated by a right-linear subgrammar. Similarly, the set of strings v is regular. Because G and G s are d-equivalent, it follows that each G (A[a] ) generates a regular language as well.", "cite_spans": [], "ref_spans": [ { "start": 120, "end": 125, "text": "(A[a]", "ref_id": null }, { "start": 375, "end": 380, "text": "(A[a]", "ref_id": null } ], "eq_spans": [], "section": "Theorem 1", "sec_num": null }, { "text": "Conversely, assume that for each maximal projection occurrence A[a] from G we have that G (A[a] ) generates a regular language. Then we can construct an alternative grammar in lin-CFG(a) generating the same language as G (A[a] ) , but now in split form. To this end, assume a finite automaton M accepting L(G (A[a] ) ) with a finite set Q of states and a transition relation \u2192. N (A[a] ) l . The requirements on split form are now clearly satisfied.", "cite_spans": [], "ref_spans": [ { "start": 90, "end": 95, "text": "(A[a]", "ref_id": null }, { "start": 221, "end": 226, "text": "(A[a]", "ref_id": null }, { "start": 309, "end": 314, "text": "(A[a]", "ref_id": null }, { "start": 378, "end": 385, "text": "N (A[a]", "ref_id": null } ], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "This section presents the main results of this article. We start with some basic notions from computability theory and with the adopted notation for Turing machines.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Undecidability Results", "sec_num": "4." }, { "text": "We use single-tape, single-head, deterministic Turing machines. A configuration of a Turing machine M is a string over some alphabet \u03a3, encoding the current content of the tape along with the position of the head on the tape and the current state. In the initial configuration, the tape contains the input to the Turing machine, the head is placed at the start of the tape, and the machine is in its (unique) initial state. An accepting configuration is any configuration of M of which the current state belongs to a distinguished set of accepting states. An accepting computation of M is a sequence of configurations of M starting with an initial configuration and ending with a final configuration, and such that consecutive configurations are related by a valid move of the machine. Without loss of generality, we assume that any accepting computation has an odd number of moves, and at least three.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Undecidability Results", "sec_num": "4." }, { "text": "For a given string w, we write w to denote the mirror image of w. Consider a Turing machine M whose configurations are defined over some alphabet \u03a3, and assume two fresh symbols $ and # not in \u03a3. Following the notation of Bordihn, Holzer, and Kutrib (2005) , we encode accepting computations of M as strings of the form:", "cite_spans": [ { "start": 222, "end": 256, "text": "Bordihn, Holzer, and Kutrib (2005)", "ref_id": "BIBREF1" } ], "ref_spans": [], "eq_spans": [], "section": "Undecidability Results", "sec_num": "4." }, { "text": "EQUATION", "cite_spans": [], "ref_spans": [], "eq_spans": [ { "start": 0, "end": 8, "text": "EQUATION", "ref_id": "EQREF", "raw_str": "w 0 $w 2 $ . . . $w 2k # w 2k+1 $ . . . $ w 3 $ w 1", "eq_num": "(2)" } ], "section": "Undecidability Results", "sec_num": "4." }, { "text": "Here, w 0 , . . . , w 2k+1 are configurations of M, with w 0 an initial configuration and w 2k+1 an accepting configuration. Furthermore, for each i with 0 \u2264 i \u2264 2k, configuration w i is related to configuration w i+1 by a valid move of M. We define VALC(M) to be the set of all valid computations of M, represented as before. We say that a string u is accepted by M if u occurs in an initial configuration w 0 in some computation in VALC(M). The language L(M) is defined to be the set of all strings accepted by M.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Undecidability Results", "sec_num": "4." }, { "text": "We rely on the following result (Hopcroft and Ullman 1979, page 189) :", "cite_spans": [ { "start": 32, "end": 68, "text": "(Hopcroft and Ullman 1979, page 189)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Undecidability Results", "sec_num": "4." }, { "text": "Lemma 2 For a Turing machine M, it is undecidable whether the language L(M) is finite. We also need the following result, which is essentially the same as a result reported by Hopcroft and Ullman (1979, Lemma 8.8, page 204) . We provide a complete proof here because we need to adapt the result to our special encoding of valid computations, which is somewhat different from that used by Hopcroft and Ullman (1979) , and because Hopcroft and Ullman only report a sketch of the proof.", "cite_spans": [ { "start": 176, "end": 223, "text": "Hopcroft and Ullman (1979, Lemma 8.8, page 204)", "ref_id": null }, { "start": 388, "end": 414, "text": "Hopcroft and Ullman (1979)", "ref_id": "BIBREF6" } ], "ref_spans": [], "eq_spans": [], "section": "Undecidability Results", "sec_num": "4." }, { "text": "For a Turing machine M, the language VALC(M) is context-free if and only if L(M) is finite.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Lemma 3", "sec_num": null }, { "text": "If L(M) is finite, then VALC(M) is also finite (because M is deterministic). Hence VALC(M) is a context-free language.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "If L(M) is an infinite language, we need to show that VALC(M) cannot be a contextfree language. To this end, we use the version of Ogden's lemma presented by Hopcroft and Ullman (1979, page 129) . This lemma states that if L is a context-free language, there exists a constant n such that, if we arbitrarily mark n or more distinct positions in a string in L, then we can write that string as uvwxy in such a way that v and x together include at least one marked position, vwx includes at most n marked positions, and uv i wx i y is in L for any i \u2265 0.", "cite_spans": [ { "start": 158, "end": 194, "text": "Hopcroft and Ullman (1979, page 129)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Assume now that VALC(M) is a CFL. Because L(M) is an infinite language, the length of its strings can be arbitrarily large. Therefore there must be a string in VALC(M) of the form:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "\u03b1 = w 0 $w 2 $ . . . $w 2k # w 2k+1 $ . . . $ w 3 $ w 1 ,", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "with w 2 having length greater than n. This is so because the initial configuration w 0 , representing the input string, can be chosen with arbitrarily large length, and only two moves of M have been applied to obtain w 2 from w 0 . Let us mark all positions of \u03b1 that fall within w 2 .", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Now let \u03b1 = uvwxy be a factorization satisfying Ogden's lemma. If v or x contain one or more occurrences of the symbol $, we can pump such a string in \u03b1 and obtain a new string which is not a valid computation, which is a contradiction. More precisely, assume that v contains exactly one occurrence of $, and write v = v $v . If we choose i = 3 in Ogden's lemma, we obtain a new string with two instances of configuration v v in it. This would imply a loop in the computation of a deterministic Turing machine, and therefore the resulting string cannot be an accepting computation. Using similar arguments, we can conclude that neither v nor x contains an occurrence of symbol $.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Because v and x together must include at least one marked position, we can distinguish two (not necessarily distinct) cases. In the first case, v is entirely included in the string w 2 . This means that we can pump w 2 to a new configuration of arbitrarily large length, without pumping w 0 . But this is a contradiction, because w 0 and w 2 are only two moves apart. In the second case, x is entirely included in the string w 2 . Similarly to the first case, we can pump w 2 to a new configuration of arbitrarily large length, without pumping w 1 , but this is also a contradiction because the two configurations are related by a single move. Therefore VALC(M) cannot be a CFL.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "We now define the set of invalid computations of M, written INVALC(M), as:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "EQUATION", "cite_spans": [], "ref_spans": [], "eq_spans": [ { "start": 0, "end": 8, "text": "EQUATION", "ref_id": "EQREF", "raw_str": "INVALC(M) = ((\u03a3 \u222a {$}) * \u2022 {#} \u2022 (\u03a3 \u222a {$}) * ) \\ VALC(M)", "eq_num": "( 3 )" } ], "section": "Proof", "sec_num": null }, { "text": "We deviate from Bordihn, Holzer, and Kutrib (2005) in that we only consider those strings in the complement of VALC(M) that contain exactly one occurrence of #. Because all the operations that need to be applied to obtain INVALC(M) from VALC(M), or vice versa, preserve regular languages, it follows that VALC(M) is a regular language if and only if INVALC(M) is a regular language. The following result relates the language INVALC(M) to the class lin-CFG(#), that is, the linear context-free grammars with center marker #, introduced in Section 2. Our proof differs somewhat from proofs of similar statements in Hopcroft and Ullman (1979) for general linear CFGs, in that the center marker has a prominent role in the grammar, and the construction must ensure that # occurs exactly once.", "cite_spans": [ { "start": 16, "end": 50, "text": "Bordihn, Holzer, and Kutrib (2005)", "ref_id": "BIBREF1" }, { "start": 613, "end": 639, "text": "Hopcroft and Ullman (1979)", "ref_id": "BIBREF6" } ], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Given a Turing machine M, one can effectively construct a grammar in lin-CFG(#) generating INVALC(M).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Lemma 4", "sec_num": null }, { "text": "Intuitively, our grammar is the union of several subgrammars, which generate, respectively: r a set of strings of the form (2) in which the w i can be arbitrary strings over \u03a3, except that w 0 must not be an initial configuration, r similarly, a set of strings of the form (2) in which w 2k+1 must not be a final configuration, r a set of strings of the form (2) in which for some i, w 2i+1 must not be the successor of w 2i , The result immediately carries over to head automaton grammars, through the standard mapping defined by Eisner and Satta (1999) .", "cite_spans": [ { "start": 531, "end": 554, "text": "Eisner and Satta (1999)", "ref_id": "BIBREF5" } ], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Our result is based on a characterization of the notion of splittability (theorem 1) in terms of a factorization of a bilexical CFG into linear context-free grammars with center markers, and on the regularity of these linear grammars. The same characterization has been claimed by Eisner and Satta (1999) relative to head automaton grammars, without a formal proof. Central to our result is a proof showing the undecidability of regularity for linear context-free grammars with center markers (Theorem 2). This strengthens an already known result stating the undecidability of regularity for general linear contextfree languages.", "cite_spans": [ { "start": 281, "end": 304, "text": "Eisner and Satta (1999)", "ref_id": "BIBREF5" } ], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "The main implication of our results is that mechanical analysis of a 2-LCFG will not suffice to determine whether the grammar is splittable or not. There are trivial sufficient conditions for splittability, as for example requiring that the grammar is already in the split form of definition 2. Also, if G (B[b] ) has a single nonterminal, for each B[b] that occurs as maximal projection in a 2-LCFG G, then G is trivially splittable. It is an open problem whether splittability is decidable in case the number of nonterminals in each G (B[b] ) is bounded by some constant larger than one. The proof techniques presented in this article do not seem to lend themselves to extension of our undecidability results in this direction. Other interesting sufficient conditions for splittability are not known.", "cite_spans": [ { "start": 306, "end": 311, "text": "(B[b]", "ref_id": null }, { "start": 537, "end": 542, "text": "(B[b]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "To obtain a more general setting, one might depart from 2-LCFGs and consider Chomsky normal form context-free grammars where each binary rule classifies its two nonterminals into functor (or predicate projection) and argument. Also in this case, one can pose the question of whether the two processes of generating the left and the right arguments of each predicate are independent one of the other. The results reported in this article can be extended to show undecidability of this question as well.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "One way to formalize this marking is to have a separate subset of delexicalized nonterminals that are part of each maximal projection occurrence and never a part of any head child occurrence.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null } ], "back_matter": [ { "text": "We are indebted to the anonymous reviewers for many detailed and helpful comments. Among other things, the terminology has been improved relative to the first version of this article. This we owe to a valuable suggestion from one of the reviewers.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Acknowledgments", "sec_num": null }, { "text": "r a set of strings of the form (2) in which for some i, w 2i must not be the successor of w 2i\u22121 , r a set of strings of the form:r a set of strings of the form:It is straightforward to construct each of these subgrammars as linear grammars with center marker #, similarly to proofs from Hopcroft and Ullman (1979, pages 203 and 215) . The statement of the theorem then follows from the fact that the class lin-CFG(#) is closed under (finite) union.We now show that it is undecidable whether a linear context-free grammar with a center marker generates a regular language. This result is stronger than a similar result stating the undecidability of regularity for general linear context-free languages, originally obtained by Hunt III and Rosenkrantz (1974) and also reported by Hopcroft and Ullman (1979, Exercise 8.10a, page 214) , in that our languages have an explicit center marker that unambiguously splits the string into two parts. Here we report a direct proof of the result for linear context-free grammars with a center marker, whereas the similar result for general linear context-free grammars is indirectly obtained by Hunt III and Rosenkrantz (1974, Corollary 2.7(5) and discussion at page 66) through sufficient conditions for the undecidability of a family of general predicates.", "cite_spans": [ { "start": 288, "end": 333, "text": "Hopcroft and Ullman (1979, pages 203 and 215)", "ref_id": null }, { "start": 726, "end": 757, "text": "Hunt III and Rosenkrantz (1974)", "ref_id": "BIBREF7" }, { "start": 779, "end": 831, "text": "Hopcroft and Ullman (1979, Exercise 8.10a, page 214)", "ref_id": null }, { "start": 1133, "end": 1181, "text": "Hunt III and Rosenkrantz (1974, Corollary 2.7(5)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "annex", "sec_num": null }, { "text": "It is undecidable whether a grammar in lin-CFG(#) generates a regular language.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Theorem 2", "sec_num": null }, { "text": "Let M be a Turing machine. We start by claiming that L(M) is finite if and only if INVALC(M) is regular. To show this, assume first that L(M) is finite. Because our Turing machines are deterministic, VALC(M) is also finite, and therefore regular. From Equation (3), it follows that INVALC(M) is regular as well. Conversely, if INVALC(M) is regular, then so is VALC(M). This means that VALC(M) is context-free and, by Lemma 3, that L(M) is finite.Suppose now that it is decidable whether a grammar in lin-CFG(#) generates a regular language. Following Lemma 4, we can effectively construct a grammar in lin-CFG(#) generating INVALC(M). Under our assumption, we can now decide whether INVALC(M) is regular and hence, by our claim, whether L(M) is finite. This contradicts Lemma 2. Hence, it must be undecidable whether a grammar in lin-CFG(#) generates a regular language.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Consider the (unambiguous) grammar that is defined by the rules:Despite rules such as A \u2192 aAa and A \u2192 bAb, which by themselves may appear to make the language non-regular, the generated language is in fact {a, b} * #{a, b} * .We now return to bilexical context-free grammars. In Section 3 we have constructed grammars G (A[a] ) out of a 2-LCFG G, for each nonterminal A[a] that occurs as maximal projection in rules from G. We then characterized splittability of G, in Theorem 1, in terms of the regularity of the languages generated by each G (A[a] ) . Note that each G (A[a] ) is in lin-CFG(a). In order to obtain the main result of this article, we only need to look at a very simple type of 2-LCFG in which we can identify a given linear context-free grammar with a center marker.", "cite_spans": [], "ref_spans": [ { "start": 320, "end": 325, "text": "(A[a]", "ref_id": null }, { "start": 544, "end": 549, "text": "(A[a]", "ref_id": null }, { "start": 571, "end": 576, "text": "(A[a]", "ref_id": null } ], "eq_spans": [], "section": "Example 4", "sec_num": null }, { "text": "Splittability of bilexical CFGs is undecidable.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Theorem 3", "sec_num": null }, { "text": "We show that the existence of an algorithm for deciding whether a 2-LCFG is splittable would imply an algorithm for deciding whether any grammar in lin-CFG(#) generates a regular language, contrary to Theorem 2.Let G 1 be a grammar in lin-CFG(#). Without any loss of generality, we assume that: = G 1 . We also observe that, for each nonterminalgenerates the regular language {b}. From Theorem 1 it then follows that G 2 is splittable if and only if G 1 is regular.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Proof", "sec_num": null }, { "text": "Splittability of 2-LCFGs is of central importance to the processing efficiency of several models that are currently being used in statistical natural language parsing, as discussed in the Introduction. The notion of splittability has been originally introduced by Eisner (1997) and Eisner and Satta (1999) for the closely related formalism of head automaton grammars. In this article we gave an equivalent definition for 2-LCFGs, through the notion of d-equivalence, and we showed that splittability of 2-LCFGs is undecidable.", "cite_spans": [ { "start": 264, "end": 277, "text": "Eisner (1997)", "ref_id": "BIBREF5" }, { "start": 282, "end": 305, "text": "Eisner and Satta (1999)", "ref_id": "BIBREF5" } ], "ref_spans": [], "eq_spans": [], "section": "Discussion", "sec_num": "5." } ], "bib_entries": { "BIBREF0": { "ref_id": "b0", "title": "Head automata and bilingual tiling: Translation with minimal representations", "authors": [ { "first": "H", "middle": [], "last": "Alshawi", "suffix": "" } ], "year": 1996, "venue": "34th Annual Meeting of the Association for Computational Linguistics, Proceedings of the Conference", "volume": "", "issue": "", "pages": "167--176", "other_ids": {}, "num": null, "urls": [], "raw_text": "Alshawi, H. 1996. Head automata and bilingual tiling: Translation with minimal representations. In 34th Annual Meeting of the Association for Computational Linguistics, Proceedings of the Conference, pages 167-176, Santa Cruz, CA.", "links": null }, "BIBREF1": { "ref_id": "b1", "title": "Some non-semi-decidability problems for linear and deterministic context-free languages", "authors": [ { "first": "H", "middle": [], "last": "Bordihn", "suffix": "" }, { "first": "M", "middle": [], "last": "Holzer", "suffix": "" }, { "first": "M", "middle": [], "last": "Kutrib", "suffix": "" } ], "year": 2005, "venue": "Implementation and Application of Automata: 9th International Conference", "volume": "", "issue": "", "pages": "68--79", "other_ids": {}, "num": null, "urls": [], "raw_text": "Bordihn, H., M. Holzer, and M. Kutrib. 2005. Some non-semi-decidability problems for linear and deterministic context-free languages. In Implementation and Application of Automata: 9th International Conference, pages 68-79, Kingston.", "links": null }, "BIBREF2": { "ref_id": "b2", "title": "Immediate-head parsing for language models", "authors": [ { "first": "E", "middle": [], "last": "Charniak", "suffix": "" } ], "year": 2001, "venue": "39th Annual Meeting and 10th Conference of the European Chapter", "volume": "", "issue": "", "pages": "116--123", "other_ids": {}, "num": null, "urls": [], "raw_text": "Charniak, E. 2001. Immediate-head parsing for language models. In 39th Annual Meeting and 10th Conference of the European Chapter of the Association for Computational Linguistics, Proceedings of the Conference, pages 116-123, Toulouse.", "links": null }, "BIBREF3": { "ref_id": "b3", "title": "Head-driven statistical models for natural language parsing", "authors": [ { "first": "M", "middle": [], "last": "Collins", "suffix": "" } ], "year": 2003, "venue": "Computational Linguistics", "volume": "29", "issue": "4", "pages": "589--637", "other_ids": {}, "num": null, "urls": [], "raw_text": "Collins, M. 2003. Head-driven statistical models for natural language parsing. Computational Linguistics, 29(4):589-637.", "links": null }, "BIBREF4": { "ref_id": "b4", "title": "Three new probabilistic models for dependency parsing: An exploration", "authors": [ { "first": "J", "middle": [], "last": "Eisner", "suffix": "" } ], "year": 1996, "venue": "The 16th International Conference on Computational Linguistics", "volume": "1", "issue": "", "pages": "340--345", "other_ids": {}, "num": null, "urls": [], "raw_text": "Eisner, J. 1996. Three new probabilistic models for dependency parsing: An exploration. In The 16th International Conference on Computational Linguistics, volume 1, pages 340-345, Copenhagen.", "links": null }, "BIBREF5": { "ref_id": "b5", "title": "Efficient parsing for bilexical context-free grammars and head automaton grammars", "authors": [ { "first": "J", "middle": [], "last": "Eisner", "suffix": "" }, { "first": "M", "middle": [ "A" ], "last": "Cambridge", "suffix": "" }, { "first": "J", "middle": [], "last": "Eisner", "suffix": "" }, { "first": "G", "middle": [], "last": "Satta", "suffix": "" } ], "year": 1997, "venue": "37th Annual Meeting of the Association for Computational Linguistics, Proceedings of the Conference", "volume": "", "issue": "", "pages": "457--464", "other_ids": {}, "num": null, "urls": [], "raw_text": "Eisner, J. 1997. Bilexical grammars and a cubic-time probabilistic parser. In International Workshop on Parsing Technologies, pages 54-65, Cambridge, MA. Eisner, J. and G. Satta. 1999. Efficient parsing for bilexical context-free grammars and head automaton grammars. In 37th Annual Meeting of the Association for Computational Linguistics, Proceedings of the Conference, pages 457-464, College Park, MD.", "links": null }, "BIBREF6": { "ref_id": "b6", "title": "Introduction to Automata Theory, Languages, and Computation", "authors": [ { "first": "J", "middle": [ "E" ], "last": "Hopcroft", "suffix": "" }, { "first": "J", "middle": [ "D" ], "last": "Ullman", "suffix": "" } ], "year": 1979, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Hopcroft, J. E. and J. D. Ullman. 1979. Introduction to Automata Theory, Languages, and Computation. Addison-Wesley, Reading, MA.", "links": null }, "BIBREF7": { "ref_id": "b7", "title": "Computational parallels between the regular and context-free languages", "authors": [ { "first": "Iii", "middle": [], "last": "Hunt", "suffix": "" }, { "first": "H", "middle": [ "B" ], "last": "", "suffix": "" }, { "first": "D", "middle": [ "J" ], "last": "Rosenkrantz", "suffix": "" } ], "year": 1974, "venue": "Conference Record of the Sixth Annual ACM Symposium on Theory of Computing", "volume": "", "issue": "", "pages": "64--74", "other_ids": {}, "num": null, "urls": [], "raw_text": "Hunt III, H. B. and D. J. Rosenkrantz. 1974. Computational parallels between the regular and context-free languages. In Conference Record of the Sixth Annual ACM Symposium on Theory of Computing, pages 64-74, Seattle, WA.", "links": null } }, "ref_entries": { "FIGREF0": { "num": null, "text": "Two parse trees for the string bcad under grammars G 1 (a) and G 2 (b) from Example 2. Both trees correspond to the same associated dependency structure (c).", "uris": null, "type_str": "figure" }, "TABREF2": { "num": null, "html": null, "content": "", "type_str": "table", "text": "For each rule occurrence A[a] \u2192 B[b] C[a] in t, a link is constructed from the corresponding occurrence of b in w to the corresponding occurrence of a. Similarly, a rule occurrence A[a] \u2192 B[a] C[c] gives rise to a link from the corresponding occurrence of c to the corresponding occurrence of a. Notice that a dependency structure abstracts away from some topological aspects of the parse trees. For example, two rules A[a] \u2192 B[a] C[c] and B[a] \u2192 D[d] E[a] could give rise to the same dependency structures as the two rules A[a] \u2192 D[d] F[a] and F[a] \u2192" }, "TABREF4": { "num": null, "html": null, "content": "
(A[a]) s Definition 2. It is not difficult to see that L(G , whose nonterminals are partitioned into sets N (A[a]) s ) is a regular language. This regular (A[a]) l and N (A[a]) as in r
language is the finite union of the languages:
B[a] \u2208 N (A[a]) lL (B[a],C[a]) s and C[a] \u2208 N (A[a]) rwith
", "type_str": "table", "text": "If G is splittable, then there exists a split 2-LCFG G s such that G and G s are d-equivalent. Let A[a] be a nonterminal of G s that occurs as maximal projection, and consider the lin-CFG(a) G = {uav | A[a] \u21d2 * uB[a] \u21d2 uC[a] \u21d2 * uav}, for all possible distinct choices of rules of the form B[a] \u2192 C[a] from G (A[a])" }, "TABREF5": { "num": null, "html": null, "content": "
Concretely, for each transition qB[b] \u2192 q such that q 1 is reachable from q , we construct
rule q[a] \u2192 B[b] q [a], and for each transition qB[b] \u2192 q such that q is reachable from q 2 , we
construct rule q [a] \u2192 q[a] B[b]. a \u2192 q 2 . Each transition q 1 a \u2192 q 2 gives rise to one such grammar. We can now take the disjoint union of such grammars for all transitions q 1 a \u2192 q 2 ,
taking different copies of automaton states q in nonterminals q[A] for each combi-
nation of q 1 and q 2 . The result is a grammar generating all strings accepted by M. Nonterminals q[a] are defined to be in N (A[a]) l or in N (A[a]) r depending on whether a state q 1 in a transition q 1 a \u2192 q 2 is reachable from q or whether q is reachable from a state q 2 in a transition q 1 a \u2192 q 2 . Naturally A[a] is taken to be in
", "type_str": "table", "text": "For each transition q 1 a \u2192 q 2 of M, we can construct rightlinear rules corresponding to transitions occurring on paths from the initial state of M to state q 1 , and left-linear rules corresponding to transitions occurring on paths from state q 2 to any final state of M. We also construct rule A[a] \u2192 q 0 [a], where q 0 is the initial state of M, and the rule q 2[a] \u2192 a. For each final state q f of M that is reachable from q 2 we furthermore construct the rule q 1 [a] \u2192 q f[a]. The resulting grammar generates the strings that are accepted by M by computations that traverse the transition q 1" } } } }