{ "paper_id": "P93-1017", "header": { "generated_with": "S2ORC 1.0.0", "date_generated": "2023-01-19T08:52:06.101125Z" }, "title": "Lexicalized Context-Free Grammars", "authors": [ { "first": "Yves", "middle": [], "last": "Schabes", "suffix": "", "affiliation": { "laboratory": "Mitsubishi Electric Research Laboratories", "institution": "", "location": { "postCode": "201, 02139", "settlement": "Broadway, Cambridge", "region": "MA" } }, "email": "" }, { "first": "Richard", "middle": [ "C" ], "last": "Waters", "suffix": "", "affiliation": { "laboratory": "Mitsubishi Electric Research Laboratories", "institution": "", "location": { "postCode": "201, 02139", "settlement": "Broadway, Cambridge", "region": "MA" } }, "email": "" } ], "year": "", "venue": null, "identifiers": {}, "abstract": "and dick((~merl.coin Lexicalized context-free grammar (LCFG) is an attractive compromise between the parsing efficiency of context-free grammar (CFC) and the elegance and lexical sensitivity of lexicalized treeadjoining grammar (LTAG). LCFC is a restricted form of LTAG that can only generate contextfree languages and can be parsed in cubic time. However, LCF(I supports much of the elegance of LTAG's analysis of English and shares with LTAG the ability to lexicalize CF(I;s without changing the trees generated. Motivation Context-free grammar (CFG) has been a well accepted framework for computational linguistics for a long time. While it has drawbacks, including the inability to express some linguistic constructions, it has the virtue of being computationally efficient, O(n3)-time in the worst case. Recently there has been a gain in interest in the so-called 'mildly' context-sensitive formalisms (", "pdf_parse": { "paper_id": "P93-1017", "_pdf_hash": "", "abstract": [ { "text": "and dick((~merl.coin Lexicalized context-free grammar (LCFG) is an attractive compromise between the parsing efficiency of context-free grammar (CFC) and the elegance and lexical sensitivity of lexicalized treeadjoining grammar (LTAG). LCFC is a restricted form of LTAG that can only generate contextfree languages and can be parsed in cubic time. However, LCF(I supports much of the elegance of LTAG's analysis of English and shares with LTAG the ability to lexicalize CF(I;s without changing the trees generated. Motivation Context-free grammar (CFG) has been a well accepted framework for computational linguistics for a long time. While it has drawbacks, including the inability to express some linguistic constructions, it has the virtue of being computationally efficient, O(n3)-time in the worst case. Recently there has been a gain in interest in the so-called 'mildly' context-sensitive formalisms (", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Abstract", "sec_num": null } ], "body_text": [ { "text": "An LTAG lexicon consists of a set of trees each of which contains one or more lexical items. These elementary trees can be viewed as the elementary clauses (including their transformational variants) in which the lexical items participate. The trees are combined by substitution and adjunction.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null }, { "text": "LTAC supports context-sensitive features that can capture some language constructs not captured by CFG. However, the greatest virtue of LTAG is that it is lexicalized and supports ex-tended domains of locality. The lexical nature of LTAC is of linguistic interest, since it is believed that the descriptions of many linguistic phenomena are dependent upon lexical data. The extended domains allow for the localization of most syntactic and semantic dependencies (e.g., fillergap and predicate-argument relationships).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null }, { "text": "A fllrther interesting aspect of LTAG is its ability to lexicalize CFCs. One can convert a CFC into an LTAG that preserves the original trees (Joshi and Schabes, 1992) .", "cite_spans": [ { "start": 142, "end": 167, "text": "(Joshi and Schabes, 1992)", "ref_id": "BIBREF1" } ], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null }, { "text": "Lexicalized context-free grammar (LCFG) is an attractive compromise between LTAG and CFG, that combines many of the virtues of LTAG with the efficiency of CFG. LCFC is a restricted form of LTAG that places further limits on the elementary trees that are possible and on the way adjunction can be performed. These restrictions limit LCFG to producing only context-free languages and allow LCFC to be parsed in O(n3)time in the worst ease. However, LCFC retains most of the key features of LTAG enumerated above.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null }, { "text": "In particular, most of the current LTAG grammar for English (Abeilld et al., 1990) follows the restrictions of LCFG. This is of significant practical interest because it means that the processing of these analyses does not require more computational resources than CFGs.", "cite_spans": [ { "start": 60, "end": 82, "text": "(Abeilld et al., 1990)", "ref_id": "BIBREF0" } ], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null }, { "text": "In addition, any CFG can be transformed into an equivalent LCFC that generates the same trees (and therefore the same strings). This result breaks new ground, because heretofore every method of lexicalizing CFCs required contextsensitive operations (Joshi and Schabes, 1992) .", "cite_spans": [ { "start": 249, "end": 274, "text": "(Joshi and Schabes, 1992)", "ref_id": "BIBREF1" } ], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null }, { "text": "The following sections briefly, define LCFG, discuss its relationship to the current LTAG grammar for English, prove that LC, FC can be used to lexicalize CFC, and present a simple cubic-time parser for LCFC. These topics are discussed in greater detail in Schabes and Waters (1993) .", "cite_spans": [ { "start": 257, "end": 282, "text": "Schabes and Waters (1993)", "ref_id": "BIBREF7" } ], "ref_spans": [], "eq_spans": [], "section": "", "sec_num": null }, { "text": "Like an LTAG, an LC'FG consists of two sets of trees: initial trees, which are combined by substitution and auxiliary trees, which are combined by adjunction. An LCFG is lexicalized in the sense that every initial and auxiliary tree is required to contain at least one terminal symbol on its frontier.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "More precisely, an LCFG is a five-tuple (Z, NT, I, A, , 5') , where ~ is a set of terminal symbols, NT is a set of non-terminal symbols, I and A are sets of trees labeled by terminal and nonterminal symbols, and ,5' is a distinguished nonterminal start symbol.", "cite_spans": [ { "start": 40, "end": 43, "text": "(Z,", "ref_id": null }, { "start": 44, "end": 47, "text": "NT,", "ref_id": null }, { "start": 48, "end": 50, "text": "I,", "ref_id": null }, { "start": 51, "end": 53, "text": "A,", "ref_id": null }, { "start": 54, "end": 55, "text": ",", "ref_id": null }, { "start": 56, "end": 59, "text": "5')", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "Each initial tree in the set I satisfies the following requirements.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "(i) Interior nodes are labeled by nonterminal symbols. (ii) The nodes on the frontier of the tree consist of zero or more non-terminal symbols and one or more terminal symbols. (iii) The non-terminal symbols on the frontier are marked for substitution. By convention, this is annotated in diagrams using a down arrow (l).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "Each auxiliary tree in the set A satisfies the following requirements.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "(i) Interior nodes are labeled by nonterminal symbols. (ii) The nodes on the frontier consist of zero or more non-terminal symbols and one or more terminal symbols. (iii) All but one of the non-terminal symbols on the frontier are marked for substitution. (iv) The remaining non-terminal on the frontier of the tree is called the foot. The label on the foot must be identical to the label on the root node of the tree. By convention, the foot is indicated in diagrams using an asterisk (.). (v) the foot must be in either the leftmost or the rightmost position on the frontier. Figure 1 , shows seven elementary trees that might appear in an LCFG for English. The trees containing 'boy', 'saw', and 'left' are initial trees. The remainder are attxiliary trees.", "cite_spans": [], "ref_spans": [ { "start": 578, "end": 586, "text": "Figure 1", "ref_id": "FIGREF0" } ], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "Auxiliary trees whose feet are leftrnost are called left recursive. Similarly, auxiliary trees whose feet are rightrnost are called righl recursive auxiliary trees. The path from the root of an auxiliary tree to the foot is called the spine. In LCF(I, trees can be combined with substitution and adjunction. As illustrated in Figure 2 , substitution replaces a node marked for substitution with a copy of an initial tree.", "cite_spans": [], "ref_spans": [ { "start": 326, "end": 334, "text": "Figure 2", "ref_id": null } ], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "NP VP N VP A /k A /X D$ N V", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "Adjunction inserts a copy of an auxiliary tree into another tree in place of an interior node that has the same label as the foot of the auxiliary tree. The subtree that was previously connected to the interior node is reconnected to the foot of the copy of the auxiliary tree. If the auxiliary tree is left recursive, this is referred to as left recursive adjunction (see Figure 3 ). If the auxiliary tree is right recursive, this is referred to as right recursive adjunction (see Figure 4 ).", "cite_spans": [], "ref_spans": [ { "start": 373, "end": 381, "text": "Figure 3", "ref_id": null }, { "start": 482, "end": 490, "text": "Figure 4", "ref_id": "FIGREF1" } ], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "Crucially, adjunction is constrained by requiring that a left recursive auxiliary tree cannot be adjoined on any node that is on the spine of a right recursive auxiliary tree and a right recursive auxiliary tree cannot be adjoined on the spine of a left recursive auxiliary tree.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "An LCFG derivation must start with an initial tree rooted in S. After that, this tree can be repeatedly extended using substitution and adjunction. A derivation is complete when every frontier node is labeled with a terminal symbol. that LTAG allows the foot of an auxiliary tree to appear anywhere on the frontier and places no limitations on the interaction of auxiliary trees. In this unlimited situation, adjunction encodes string wrapping and is therefore more powerful than concatenation (see Figure 5 ). However, the restrictions imposed by LCFG guarantee that no context-sensitive operations can be achieved. They limit the languages that can be generated by LCFGs to those that can be generated by CFGs.", "cite_spans": [], "ref_spans": [ { "start": 499, "end": 507, "text": "Figure 5", "ref_id": null } ], "eq_spans": [], "section": "Context-Free Grammars", "sec_num": null }, { "text": "The power of LCFG is significantly less than LTAG. Surprisingly, it turns out that there are only two situations where the current LTAG grammar for English (Abeilld et al., 1990 ) fails to satisfy the restrictions imposed by LCFG.", "cite_spans": [ { "start": 156, "end": 177, "text": "(Abeilld et al., 1990", "ref_id": "BIBREF0" } ], "ref_spans": [], "eq_spans": [], "section": "Coverage of LCFG and LTAG", "sec_num": null }, { "text": "The first situation, concerns certain verbs that take more than one sentential complement. An example of such a verb is deduce, which is associated with the following auxiliary tree.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Coverage of LCFG and LTAG", "sec_num": null }, { "text": "V Sl* PP I A deduce P Sz,I, I from", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S NPo$ VP", "sec_num": null }, { "text": "Since this tree contains a foot node in the center of its frontier, it is not part of an LCFG. Having the foot on the first sentential complement is convenient, because it allows one to use the standard LTAG wh-analyses, which depends on the w2 ~ W4 % Figure 5 : Adjunction in LTAG.", "cite_spans": [], "ref_spans": [ { "start": 252, "end": 260, "text": "Figure 5", "ref_id": null } ], "eq_spans": [], "section": "S NPo$ VP", "sec_num": null }, { "text": "existence of an initial tree where the filler and gap are local. This accounts nicely for the pair of sentences below. However, other analyses of wh questions may not require the use of the auxiliary tree above.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S NPo$ VP", "sec_num": null }, { "text": "(1) John deduced that Mary watered the grass from seeing the hose. (2) What did John deduce that Mary watered from seeing the hose.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S NPo$ VP", "sec_num": null }, { "text": "The second situation, concerns the way the current LTAG explains the ambiguous attachments of adverbial modifiers. For example, in the sentence:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S NPo$ VP", "sec_num": null }, { "text": "(3) John said Bill left yesterday. interaction along the spine of these two kinds of trees. This agrees with the intuition that most English analyses do not require a context-sensitive operation.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S NPo$ VP", "sec_num": null }, { "text": "LCFG. However, as shown below, combining extended substitution with restricted adjunction allows strong lexicalization of CFG, without introducing greater parsing complexity than CFG.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S NPo$ VP", "sec_num": null }, { "text": "The lexicalization of grammar formalisms is of interest from a number of perspectives. It is of interest from a linguistic perspective, because most current linguistic theories give lexical accounts of a number of phenomena that used to be considered purely syntactic. It is of interest from a computational perspective, because lexicalized grammars can be parsed significantly more efficiently than non-lexicalized ones (Schabes and Joshi, 1990 ).", "cite_spans": [ { "start": 421, "end": 445, "text": "(Schabes and Joshi, 1990", "ref_id": "BIBREF5" } ], "ref_spans": [], "eq_spans": [], "section": "Lexicalization of CFGs", "sec_num": null }, { "text": "Formally, a grammar is said 'lexicalized' (Schabes, Abeill~., and Joshi, 1988) if it consists of: ,, a finite set of elementary structures of finite size, each of which c, ontains an overt (i.e., non-empty) lexical item. \u2022 a finite set of operations for creating derived structures.", "cite_spans": [ { "start": 62, "end": 78, "text": "and Joshi, 1988)", "ref_id": "BIBREF4" } ], "ref_spans": [], "eq_spans": [], "section": "Lexicalization of CFGs", "sec_num": null }, { "text": "The overt lexical item in an elementary structure is referred to as its anchor. A lexicalized grammar can be organized as a lexicon where each lexical item is associated with a finite number of structures for which that item is the anchor.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Lexicalization of CFGs", "sec_num": null }, { "text": "In general, CFGs are not lexicalized since rules such as ,5' --* NP VP that do not locally introduce lexical items are allowed. In contrast, the wellknown Creibach Normal Form (CNF) for CFCs is lexicalized, because every production rule is required to be of the form A --+ ac~ (where a is a terminal symbol, A a non-terminal symbol and a a possibly empty string of non-terminal symbols) and therefore locally introduces a lexical item a.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Lexicalization of CFGs", "sec_num": null }, { "text": "It can be shown that for any CFG (.7 (that does not derive the empty string), there is a CNF grammar (.7 ~ that derives the same language. However, it may be impossible for the set of trees produced by (7 ~ to be the same as the set of trees produced by G.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Lexicalization of CFGs", "sec_num": null }, { "text": "Therefore, CNF achieves a kind of lexicalization of CFGs. However, it is only a weak lexicalization, because the set of trees is not necessarily preserved. As discussed in the motivation section, strong lexicalization that preserves tree sets is possible using LTAG. However, this is achieved at the cost of significant additional parsing complexity.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Lexicalization of CFGs", "sec_num": null }, { "text": "Heretofore, several attempts have been made to lexicalize CFC with formalisms weaker than LTAG, but without success. In particular, it is not sufficient to merely extend substitution so that it applies to trees. Neither is it sutficient to rely solely on the kind restricted adjunction used by", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Lexicalization of CFGs", "sec_num": null }, { "text": "If G = (~,NT, P,S) is a finitely ambiguous CFG which does not generate the empty .string (\u00a2), then there is an LCFG (7 ~ = (~, NT, I, A, S) generating the same language and tree set as (7. Furthermore (7' can be chosen .so that it utilizes only lefl-recursive auxiliary trees.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Theorem", "sec_num": null }, { "text": "As usual in the above, a CFG (.7 is a fourtuple, (E, NT, P, S) , where N is a set of terminal symbols, NT is a set of non-terminal symbols, P is a set of production rules that rewrite non-terminal symbols to strings of terminal and non-terminal symbols, and S is a distinguished non-terminal symbol that is the start symbol of any derivation.", "cite_spans": [ { "start": 49, "end": 62, "text": "(E, NT, P, S)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Theorem", "sec_num": null }, { "text": "To prove the theorem we first prove a somewhat weaker theorem and then extend the proof to the flfll theorem. In particular, we assume for the moment that the set of rules for (.7 does not contain any empty rules of the form A ~ e.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Theorem", "sec_num": null }, { "text": "Step 1 We begin the construction of (7 ~ by constructing a directed graph LCG that we call the left corner derivation graph. Paths in LCG correspond to leftmost paths from root to frontier in (partial) derivation trees rooted at non-terminal symbols in (1. L(TG contains a node for every symbol in E U NT and an arc for every rule in P as follows. For each terminal and non-terminal symbol X in G create a node in LCG labeled with X. For each rule X --+ Ya in G create a directed arc labeled with X ~ Ya from the node labeled with X to the node labeled Y.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Theorem", "sec_num": null }, { "text": "As an example, consider the example CFG in Figure 7 and the corresponding L(TG shown in Figure 8 .", "cite_spans": [], "ref_spans": [ { "start": 43, "end": 51, "text": "Figure 7", "ref_id": null }, { "start": 88, "end": 96, "text": "Figure 8", "ref_id": "FIGREF3" } ], "eq_spans": [], "section": "Theorem", "sec_num": null }, { "text": "The significance of L(;G is that there is a oneto-one correspondence between paths in LCG ending on a non-terminal and left corner derivations in G. A left corner derivation in a CFG is a partial derivation starting from any non-terminal where every expanded node (other than the root) is the leftmost child of its parent and the left corner is a non-terminal. A left corner derivation is uniquely identified by the list of rules applied. Since G does not have any empty rules, every rule in (7 is represented in L(;'G. Therefore, every path in LCG ending on a terminal corresponds to a left corner derivation in (7 and vice versa. Step 2 The set of initial trees I for G' is constructed with reference to L(TG. In particular, an initial tree is created corresponding to each noncyclic path in L(/G that starts at a non-terminal symbol X and ends on a terminal symbol y. (A non-cyclic path is a path that does not touch any node twice.)", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Theorem", "sec_num": null }, { "text": "For each non-cyclic path in LCG from X to y, construct an initial tree T as follows. Start with a root labeled X. Apply the rules in the path one after another, always expanding the left corner node of T. While doing this, leave all the non-left corner non-terminal symbols in T unexpanded, and label them as substitution nodes.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "Given the previous example grammar, this step produces the initial trees shown in Figure 9 .", "cite_spans": [], "ref_spans": [ { "start": 82, "end": 90, "text": "Figure 9", "ref_id": "FIGREF4" } ], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "Each initial tree created is lexicalized, because each one has a non-terminal symbol as the left corner element of its frontier. There are a finite number of initial trees, because the number of noncyclic paths in LCG must be finite. Each initial tree is finite in size, because each non-cyclic path in LCG is finite in length.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "Most importantly, The set of initial trees is the set of non-recursive left corner derivations in (,'. Step 3 This step constructs a set of leftrecursive auxiliary trees corresponding to the cyclic path segments in L(TG that were ignored in the previous step. In particular, an attxiliary tree is created corresponding to each minimM cyclic path in LCG that starts at a non-terminM symbol.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "For each minimal cycle in LCG from X to itself, construct an auxiliary tree T by starting with a root labeled X and repeatedly expanding left, corner frontier nodes using the rules in the path as in Step 2. When all the rules in the path have been used, the left corner frontier node in T will be labeled X. Mark this as the foot node of T. While doing the above, leave all the other non-terminal symbols in T unexpanded, and label them all substitution nodes.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "The LC(; in Figure 8 has two minimal cyclic paths (one from A to A via B and one from B to B via A). This leads to the the two auxiliary trees shown in Figure 10 , one for A and one for B.", "cite_spans": [], "ref_spans": [ { "start": 12, "end": 20, "text": "Figure 8", "ref_id": "FIGREF3" }, { "start": 152, "end": 161, "text": "Figure 10", "ref_id": "FIGREF0" } ], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "The attxiliary trees generated in this step are not, necessarily lexicalized. There are a finite number of auxiliary trees, since the number of minimal cyclic paths in G must be finite. Each auxiliary tree is finite in size, because each minimal-cycle in LCG is finite in length.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "The set of trees that can he created by cornbiding the initial trees from Step 2 with the auxiliary trees from Step 3 by adjoining auxiliary trees along the left edge is the set of every left corner derivation in (,'. To see this, consider that every path in L(;G can be represented as an initial non-cyclic path with zero or more minimal cycles inserted into it.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "The set of trees that can be created by cornbiding the initial trees from Step 2 with the auxiliary trees from Step 3 using both substitution and adjunction is the set of every derivation in G. To see this, consider that every derivation in G can be decomposed into a set of left corner derivations in G that are combined with substitution. In particular, whenever a non-terminal node is not the leftmost child of its parent, it is the head of a sep- arate left corner derivation.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "Step 4 This step lexicalizes the set of auxiliary trees built in step 3, without altering the trees that can be derived.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "For each auxiliary tree T built in step 3, consider the frontier node A just to the right of the foot. If this node is a terminal do nothing. Otherwise, remove T from the set of auxiliary trees replace it with every tree that can be constructed by substituting one of the initial trees created in Step 2 for the node A in T.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "In the case of our continuing example, Step 4 results in the set of auxiliary trees in Figure 11 .", "cite_spans": [], "ref_spans": [ { "start": 87, "end": 96, "text": "Figure 11", "ref_id": "FIGREF0" } ], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "Note that since G is finitely ambiguous, there must be a frontier node to the right of the foot of an attxiliary tree T. If not, then T would correspond to a derivation X:~X in G and 6' would be infinitely ambiguous.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "S---+A A ,5' --+ B A A--+B B B--+ A S B ----+ b", "sec_num": null }, { "text": "Step 4, every auxiliary tree is lexicalized, since every tree that does not have a terminal to the right of its foot is replaced by one or more trees that do. Since there were only a finite number of finite initial and auxiliary trees to start with, there are still only a finite number of finite attxiliary trees.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "After", "sec_num": null }, { "text": "Step 4 does not alter the set of trees that can be produced in any way, because the only change that was made was to make substitutions that could be made anyway, and when a substitutable node was eliminated, this was only done after every possible substitution at that node was performed.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The change in the auxiliary trees caused by", "sec_num": null }, { "text": "Note that the initial trees are left anchored and the auxiliary trees are ahnost left anchored in the sense that the leftmost frontier node other than the foot is a terminal. This facilitates efficient left to right parsing. The procedure above creates a lexicalized grammar that generates exactly the same trees as G and therefore the same strings. The only remaining issue is the additional assumption that G does not contain any empty rules. If (; contains an empty rule A ~ e one first uses standard methods to transform (; into an equivalent grammar H that does not have any such rule. When doing this, create a table showing how each new rule added is related to the empty rules removed. Lexicalize H producing H' using the procedure above. Derivations in H' result in elements of the tree set of H. By means of the table recording the relationship between (; and H, these trees can be converted to derivations in G.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The change in the auxiliary trees caused by", "sec_num": null }, { "text": "[]", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The change in the auxiliary trees caused by", "sec_num": null }, { "text": "There are several places in the algorithm where greater freedom of choice is possible. For instance, when lexicalizing the auxiliary trees created in", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Additional issues", "sec_num": null }, { "text": "Step 3, you need not do anything if there is any frontier node that is a terminal and you can choose to expand any frontier node you want. For instance you might want to choose the node that corresponds to the smallest number of initial trees.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Additional issues", "sec_num": null }, { "text": "Alternatively, everywhere in the procedure, the word 'left' can be replaced by 'right' and vice versa. This results in the creation of a set of right anchored initial trees and right recursive auxiliary trees. This can be of interest when the right corner derivation graph has less cycles than the left corner one.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Additional issues", "sec_num": null }, { "text": "The number of trees in G' is related to the number of non-cyclic and minimal cycle paths in LCG. In the worst case, this number rises very fast as a function of the number of arcs in LCG, (i.e., in the number of rules in G). (A fully connected graph of n 2 arcs between n nodes has n! acyclic paths and n! minimal cycles.) However, in the typical case, this kind of an explosion of trees is unlikely.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Additional issues", "sec_num": null }, { "text": "Just as there can be many ways for a CF(~ to derive a given string, there can be many ways for an LCFG to derive a given tree. For maximal efficiency, it would be desirable for the grammar G' produced by the procedure above to have no ambiguity in they way trees are derived. Unfortunately, the longer the minimal cycles in LCG, the greater the tree-generating ambiguity the procedure will introduce in G'. However, by modifying the procedure to make use of constraints on what attxiliary trees are allowed to adjoin on what nodes in which initial trees, it should be possible to reduce or even eliminate this ambiguity.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Additional issues", "sec_num": null }, { "text": "All these issues are discussed at greater length in Schabes and Waters (1993) .", "cite_spans": [ { "start": 52, "end": 77, "text": "Schabes and Waters (1993)", "ref_id": "BIBREF7" } ], "ref_spans": [], "eq_spans": [], "section": "Additional issues", "sec_num": null }, { "text": "Since LCFG is a restricted case of tree-adjoining grammar (TAG), standard O(nG)-time TAG parsers (Vijay-Shanker, 1987; Schabes, 1991; Lang, 1990 ) can be used for parsing LCFG. Further, they can be straightforwardly modified to require at most O(n4)-tirne when applied to LCFG. However, this still does not take fifll advantage of the context-freeness of LCFC. This section describes a simple I)ottom-up recognizer for LCFG that is in the style of the CKY parser for (IT(I;. The virtue of this algorithm is that it shows in a simple manner how the O(n3)-time worst case complexity can be achieved for LCFG. Schabes and Waters (1993) describes a more practical and more elaborate (Earley-style) recognizer for LCFC, which achieves the same bounds.", "cite_spans": [ { "start": 97, "end": 118, "text": "(Vijay-Shanker, 1987;", "ref_id": "BIBREF11" }, { "start": 119, "end": 133, "text": "Schabes, 1991;", "ref_id": "BIBREF8" }, { "start": 134, "end": 144, "text": "Lang, 1990", "ref_id": "BIBREF3" }, { "start": 607, "end": 632, "text": "Schabes and Waters (1993)", "ref_id": "BIBREF7" } ], "ref_spans": [], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "Suppose that G = (E, NT, I,A,S) is an LCFG and that al'\"a,~ is an input string. We can assume without loss of generality 1 that every node in I U A has at most two children.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "Let 71 be a node in an elementary tree (identified by the name of the tree and the position of the node in the tree). The central concept of the algorithrn is the concepts of spanning and covering. 71 spans a string ai+l ...aj if and only if there is some tree derived by ('; for which it is the case that the fringe of the subtree rooted at 71 is ai+l \"\" \"aj.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "In particular, a non-terminal node spans aj if and only if the label on the node is aj. A non-terrninal node spans ai+ 1 ...aj if and only if ai+l ...aj is the concatenation in left, to right order of strings spanned by the children of the node.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "\u2022 If 7 / does not subsume the foot node of an auxiliary tree then: 71 covers the string ai+ 1 ...aj if and only if it spans ai+l\" .aj.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "\u2022 If 7 / is on the spine of a right recursive auxiliary tree T then: 71 covers ai+l.\" .aj if and only if 7 / spans some strin~ that is the concatenation of ai+l -..aj and a string spanned by the foot of T. (This situation is illustrated by the right drawing in Figure 12 , in which 7 / is labeled with B.) The algorithm stores pairs of the form (71, pos) in an n by n array C. In a pair, pos is either t (for top) or b (for bottom). For every node 7l in every elementary tree in (;, the algorithm guarantees the following.", "cite_spans": [], "ref_spans": [ { "start": 261, "end": 270, "text": "Figure 12", "ref_id": "FIGREF0" } ], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "\u2022 ('l,b) e C[i,j] if and only if,I covers ai+l ...aj.", "cite_spans": [ { "start": 2, "end": 17, "text": "('l,b) e C[i,j]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "\u2022 ('l,t) E C [i,j] if and only if ('l,b} E C, [i,j] or ai+l ...aj is the concatenation (in either order) of a string covered by 7 / and a string covered by an auxiliary tree that can be adjoined on 71 .", "cite_spans": [ { "start": 2, "end": 8, "text": "('l,t)", "ref_id": null }, { "start": 13, "end": 18, "text": "[i,j]", "ref_id": null }, { "start": 46, "end": 51, "text": "[i,j]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "The algorithm fills the upper diagonal portion of the array C[i, j] (0 < i < j _< n) for increasing values of j -i. The process starts by placing each foot node in every cell C' [i,i] and each terminal node 71 in every cell C[i, i + 1] where 71 is labeled", "cite_spans": [ { "start": 178, "end": 183, "text": "[i,i]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Parsing LCFG", "sec_num": null }, { "text": "The algorithm then considers all possible ways of combining covers into longer covers. In particular, it fills the cells C[i, i + k] for increasing values of k by combining elements from the cells C [i, j] and C[j,i + k] for all j such that i < j < i + k. There are three situations where combination is possible: sibling concatenation, left recursive concatenation, and right recursive concatenation.", "cite_spans": [ { "start": 199, "end": 205, "text": "[i, j]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "ai+l \u2022", "sec_num": null }, { "text": "Sibling concatenation is illustrated in Figure 13. Suppose that there is a node 7/0 (labeled B) with two children 711 (labeled A) and 712 (labeled A'). If (711 , t) E C [i, j] and ('12, t} E (7[j, i + k] then ('1o, b) ", "cite_spans": [ { "start": 169, "end": 175, "text": "[i, j]", "ref_id": null }, { "start": 180, "end": 203, "text": "('12, t} E (7[j, i + k]", "ref_id": null }, { "start": 209, "end": 217, "text": "('1o, b)", "ref_id": null } ], "ref_spans": [ { "start": 40, "end": 46, "text": "Figure", "ref_id": null } ], "eq_spans": [], "section": "ai+l \u2022", "sec_num": null }, { "text": "E C[i, i + k].", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "ai+l \u2022", "sec_num": null }, { "text": "Left recursive concatenation is illustrated in Figure 14 . Here, the cover of a node is combined with the cover of a left auxiliary tree that can be adjoined at the node. Right recursive concatenation, which is shown in Figure 15 is analogous.", "cite_spans": [], "ref_spans": [ { "start": 47, "end": 56, "text": "Figure 14", "ref_id": "FIGREF0" }, { "start": 220, "end": 229, "text": "Figure 15", "ref_id": "FIGREF0" } ], "eq_spans": [], "section": "ai+l \u2022", "sec_num": null }, { "text": "For simplicity, the recognizer is written in two parts.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "ai+l \u2022", "sec_num": null }, { "text": "A main procedure and a subprocedure Add (node, pos, i,j) particular, one could consider stochastic extensions, LP~ parsing, and non-deterministic LR parsing.", "cite_spans": [ { "start": 40, "end": 56, "text": "(node, pos, i,j)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "ai+l \u2022", "sec_num": null } ], "back_matter": [ { "text": "We thank John Coleman who, by questioning whether the context-sensitivity of stochastic LTAG was actually being used for English, triggered this work. We thank Aravind Joshi, Fernando Pereira, Stuart Shieber and B. Srinivas for valuable discussions.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Acknowledgments", "sec_num": null }, { "text": ";; foot node initialization ( , [z, i] ) for i = 0 to n for all foot node 71 in A call Add0/, b, i, i) ;; terminal node initialization ((;[i, i + 1]) fori=0 ton-l for all node 71 in A U I labeled by ai+l call Add0/, t, i, i + 1);; induction (G'[i, i + k] = (; [i, j] + (:[j, i + k]) for k = 2 to n for i = 0 to n-k forj=i+ 1 toi+k-1 ;; sibling concatenation if (711 , l) 6 C, [i, j] and (712, t) e C[j, i + k] and r/1 is the left sibling of 7/2 with common parent 71othen Add(710 , b, i, i + k);; left recursive concatenation if {71, b) E C [i, j] and (p, t} e (,'[/, i + k] and p is the root node of a left recursive auxiliary tree that can adjoin on rl then Add0j , t, i, i + k);; right recursive concatenation if {'l, b) e (; [j, i + k] and (p, t) E C[i, j] and p is the root node of a right recursive auxiliary tree that can adjoin on 7 I then Add(r/, t, i, i + k) if (7/, z) e c[0, 7q and 71 is labeled by ,5' and 71 is the root node of an initial tree in I then return acceptance otherwise return rejection end Note that the sole purl)ose of the codes t and b is to insure that only one auxiliary tree can adjoin on a node. The procedure could easily be modified to account for other constraints on the way derivation should proceed such as those suggested for LTAGs (Schabes and Shieber, 1992) .The procedure Add puts a pair into the array C. If the pair is already present, nothing is (lone. However, if it is new, it is added to (7 and other pairs may be added as well. These correspond to cases where the coverage is not increased: when a node is the only child of its parent, when the node is recognized without adjunction, and when substitution occurs.Procedure Add(r/, pos, i, j) begin Put (rl, pos) in C, [i, j] if pos = t and r I is the only child of a parent It call Add (#, b, i, j) if pos = t and r\u00c2 is the root node of an initial tree, for each substitution node p at which 71 can substitute call Add (p, t, i, j) ;; no adjunction if pos = bif the node 7/does not have an OA constraint call Add(r/, t, i, j) endThe O(n 3) complexity of the recognizer follows from the three nested induction loops on k, i and j. (Although the procedure Add is defined recursively, the number of pairs added to (7 is bounded by a constant that is independent of sentence length.)By recording how each pair was introduced in each cell of the array C, one can easily extend the recognizer to produce all derivations of the input.", "cite_spans": [ { "start": 32, "end": 38, "text": "[z, i]", "ref_id": null }, { "start": 87, "end": 93, "text": "Add0/,", "ref_id": null }, { "start": 94, "end": 96, "text": "b,", "ref_id": null }, { "start": 97, "end": 99, "text": "i,", "ref_id": null }, { "start": 100, "end": 102, "text": "i)", "ref_id": null }, { "start": 260, "end": 282, "text": "[i, j] + (:[j, i + k])", "ref_id": null }, { "start": 376, "end": 382, "text": "[i, j]", "ref_id": null }, { "start": 541, "end": 547, "text": "[i, j]", "ref_id": null }, { "start": 552, "end": 574, "text": "(p, t} e (,'[/, i + k]", "ref_id": null }, { "start": 729, "end": 739, "text": "[j, i + k]", "ref_id": null }, { "start": 1273, "end": 1300, "text": "(Schabes and Shieber, 1992)", "ref_id": "BIBREF6" }, { "start": 1719, "end": 1725, "text": "[i, j]", "ref_id": null }, { "start": 1787, "end": 1799, "text": "(#, b, i, j)", "ref_id": null }, { "start": 1920, "end": 1932, "text": "(p, t, i, j)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Procedure recognizer begin", "sec_num": null }, { "text": "LCFG combines much of the power of LTAG with tile computational efficiency of CFG. It supports most of the same linguistic analysis supported by LTAC. In particular, most of the current LTAG for English falls into LCFG. In addition, LCFC can lexicalize CFG without altering the trees produced. Finally, LCFG can be parsed in O(n3)time.There are many directions in which the work on LCFG described here could be extended. In", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Conclusion", "sec_num": null } ], "bib_entries": { "BIBREF0": { "ref_id": "b0", "title": "A lexicalized tree adjoining grammar for English", "authors": [ { "first": "Anne", "middle": [], "last": "Abeilld", "suffix": "" }, { "first": "Kathleen", "middle": [ "M" ], "last": "Bishop", "suffix": "" }, { "first": "Sharon", "middle": [], "last": "Cote", "suffix": "" }, { "first": "Yves", "middle": [], "last": "Schabes", "suffix": "" } ], "year": 1990, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Abeilld, Anne, Kathleen M. Bishop, Sharon Cote, and Yves Schabes. 1990. A lexicalized tree adjoining grammar for English. Technical Re- port MS-CIS-90-24, Department of Computer and Information Science, University of Penn- sylvania.", "links": null }, "BIBREF1": { "ref_id": "b1", "title": "Treeadjoining grammars and lexicalized grammars", "authors": [ { "first": "Aravind", "middle": [ "K" ], "last": "Joshi", "suffix": "" }, { "first": "Yves", "middle": [], "last": "Schabes", "suffix": "" } ], "year": 1992, "venue": "Maurice Nivat and Andreas Podelski", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Joshi, Aravind K. and Yves Schabes. 1992. Tree- adjoining grammars and lexicalized gram- mars. In Maurice Nivat and Andreas Podel- ski, editors, Tree Automata and Languages. Elsevier Science.", "links": null }, "BIBREF2": { "ref_id": "b2", "title": "The convergence of mildly context-sensitive grammatical formalisms", "authors": [ { "first": "Aravind", "middle": [ "K" ], "last": "Joshi", "suffix": "" }, { "first": "K", "middle": [], "last": "Vijay-Shanker", "suffix": "" }, { "first": "David", "middle": [], "last": "Weir", "suffix": "" } ], "year": 1991, "venue": "Foundational Issues in Nalural Language Processing", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Joshi, Aravind K., K. Vijay-Shanker, and David Weir. 1991. The convergence of mildly context-sensitive grammatical formalisms. In Peter Sells, Stuart Shieber, and Tom Wasow, editors, Foundational Issues in Nalural Lan- guage Processing. MIT Press, Cambridge MA.", "links": null }, "BIBREF3": { "ref_id": "b3", "title": "The systematic constructions of Earley parsers: Application to the production of O(n 6) Earley parsers for Tree Adjoining Grammars", "authors": [ { "first": "Bernard", "middle": [], "last": "Lang", "suffix": "" } ], "year": 1990, "venue": "Proceedings of the Ist International Workshop on Tree Adjoining Grammars", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Lang, Bernard. 1990. The systematic construc- tions of Earley parsers: Application to the production of O(n 6) Earley parsers for Tree Adjoining Grammars. In Proceedings of the Ist International Workshop on Tree Adjoining Grammars, Dagstuhl C, astle, FRG, August.", "links": null }, "BIBREF4": { "ref_id": "b4", "title": "Parsing strategies with 'lexicalized' grammars: Application to tree adjoining grammars", "authors": [ { "first": "Yves", "middle": [], "last": "Schabes", "suffix": "" }, { "first": "Anne", "middle": [], "last": "Abeill6", "suffix": "" }, { "first": "Aravind", "middle": [ "K" ], "last": "Joshi", "suffix": "" } ], "year": 1988, "venue": "Proceedings of the 12 th International Conference on Computational Linguistics (COLING'88)", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Schabes, Yves, Anne Abeill6, and Aravind K. Joshi. 1988. Parsing strategies with 'lexical- ized' grammars: Application to tree adjoining grammars. In Proceedings of the 12 th Interna- tional Conference on Computational Linguis- tics (COLING'88), Budapest, Hungary, An- gust.", "links": null }, "BIBREF5": { "ref_id": "b5", "title": "Parsing with lexicalized tree adjoining grammar", "authors": [ { "first": "Yves", "middle": [], "last": "Schabes", "suffix": "" }, { "first": "Aravind", "middle": [ "K" ], "last": "Joshi", "suffix": "" } ], "year": 1990, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Schabes, Yves and Aravind K. Joshi. 1990. Pars- ing with lexicalized tree adjoining grammar. In Masaru Tomita, editor, C, urrent Issues in Parsing Technologies. Kluwer Accademic Publishers.", "links": null }, "BIBREF6": { "ref_id": "b6", "title": "An alternative conception of tree-adjoining derivation", "authors": [ { "first": "Yves", "middle": [], "last": "Schabes", "suffix": "" }, { "first": "Stuart", "middle": [], "last": "Shieber", "suffix": "" } ], "year": 1992, "venue": "20 th Meeting of the Association for (,'omputational Linguistics (A CL '92)", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Schabes, Yves and Stuart Shieber. 1992. An al- ternative conception of tree-adjoining deriva- tion. In 20 th Meeting of the Association for (,'omputational Linguistics (A CL '92).", "links": null }, "BIBREF7": { "ref_id": "b7", "title": "Lexicalized context-free grammar: A cubic-time parsable formalism that strongly lexicalizes context-free grammar", "authors": [ { "first": "Yves", "middle": [], "last": "Schabes", "suffix": "" }, { "first": "Richard", "middle": [ "C" ], "last": "Waters", "suffix": "" } ], "year": null, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Schabes, Yves and Richard C. Waters. 1993. Lex- icalized context-free grammar: A cubic-time parsable formalism that strongly lexicalizes context-free grammar. Technical Report 93- 04, Mitsubishi Electric Research Laboratories, 201 Broadway. Cambridge MA 02139.", "links": null }, "BIBREF8": { "ref_id": "b8", "title": "The valid prefix property and left to right parsing of tree-adjoining grammar", "authors": [ { "first": "Yves", "middle": [], "last": "Schabes", "suffix": "" } ], "year": 1991, "venue": "Proceedings of the second International Workshop on Parsing Technologies", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Schabes, Yves. 1991. The valid prefix prop- erty and left to right parsing of tree-adjoining grammar. In Proceedings of the second Inter- national Workshop on Parsing Technologies, Cancan, Mexico, February.", "links": null }, "BIBREF9": { "ref_id": "b9", "title": "The equivalence of four extensions of context-free grammars", "authors": [ { "first": "K", "middle": [], "last": "Vijay-Shanker", "suffix": "" }, { "first": "David", "middle": [], "last": "Weir", "suffix": "" } ], "year": 1993, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Vijay-Shanker, K. and David Weir. 1993a. The equivalence of four extensions of context-free grammars. To appear in Mathematical Sys- tems Theory.", "links": null }, "BIBREF10": { "ref_id": "b10", "title": "Parsing some constrained grammar formalisms", "authors": [ { "first": "K", "middle": [], "last": "Vijay-Shanker", "suffix": "" }, { "first": "[)avid", "middle": [], "last": "Weir", "suffix": "" } ], "year": 1993, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Vijay-Shanker, K. and [)avid Weir. 1993b. Pars- ing some constrained grammar formalisms. To appear in Computational Linguistics.", "links": null }, "BIBREF11": { "ref_id": "b11", "title": "Characterizing Mildly Context-,5\u00a5nsitive Grammar Formalisms", "authors": [ { "first": "K", "middle": [], "last": "Vijay-Shanker", "suffix": "" } ], "year": 1987, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Vijay-Shanker, K. 1987. A Study of Tree Adjoin- ing Grammars. Ph.D. thesis, Department of Computer and Information Science, Univer- sity of Pennsylvania. Weir, David J. 1988. Character- izing Mildly Context-,5\u00a5nsitive Grammar For- malisms. Ph.D. thesis, Department of Com- puter and Information Science, University of Pennsylvania.", "links": null } }, "ref_entries": { "FIGREF0": { "uris": null, "type_str": "figure", "num": null, "text": "Sample trees." }, "FIGREF1": { "uris": null, "type_str": "figure", "num": null, "text": "Right recursive adjunction." }, "FIGREF2": { "uris": null, "type_str": "figure", "num": null, "text": "the attachment of yesterday is ambiguous. The two different LTAG derivations indicated in Figure 6 represent this conveniently.Unfortunately, in LCFG the high attachment of yesterday is forbidden since a right auxiliary tree (corresponding to yesterday) is adjoined on the spines of a left auxiliary tree (corresponding to John said). However, one could avoid this problem by designing a mechanism to recover the high attachment reading from the low one.Besides the two cases presented above, the current LTAG for English uses only left and right recursive auxiliary trees and does not allow any Two LTAG derivations for John said Bill left yesterday." }, "FIGREF3": { "uris": null, "type_str": "figure", "num": null, "text": "The LC(; created by Step 1." }, "FIGREF4": { "uris": null, "type_str": "figure", "num": null, "text": "Initial trees created by Step 2." }, "FIGREF5": { "uris": null, "type_str": "figure", "num": null, "text": "Auxiliary trees created by Step 3." }, "FIGREF6": { "uris": null, "type_str": "figure", "num": null, "text": "Figure 1l: Auxiliary trees created by Step 4." }, "FIGREF7": { "uris": null, "type_str": "figure", "num": null, "text": "If 71 is on the spine of a left recursive auxiliary tree T then: 71 covers ai+] \" .aj if and only if 71 spans some string that is the concatenation of a string spanned by the foot of T and ai+l ...aj. (This situation is illustrated by the left drawing in Figure 12, in which 71 is labeled with B.) lit can be easily shown that by adding new nodes ('4 \"~ any L ,F(., can be transformed into an equivalent LC, FG satisfying this condition. A, ai+l-.-aj ai+l.., aj A* Coverage of nodes on the spine." }, "FIGREF8": { "uris": null, "type_str": "figure", "num": null, "text": "Sibling concatenation." }, "TABREF1": { "type_str": "table", "num": null, "text": ", which adds the pair (node, pos) into C[i, j].", "html": null, "content": "
a. ...a. t+l Jaj+l'\"akai+ 1\"'\"ak
" } } } }